@kwonye/mcpx 0.1.97 → 0.1.99

package/dist/{cli-vy81xjm0.js → cli-b0xrqsjc.js}

@@ -3,28 +3,733 @@ import {
   loadProjectConfig,
   saveConfig,
   saveProjectConfig
-} from "./cli-g4w6k655.js";
+} from "./cli-dy7x0zrg.js";
 import {
+  SecretsManager,
   ensureGatewayToken
-} from "./cli-remv48t3.js";
+} from "./cli-1ewrsfj4.js";
 import {
   ensureDir,
   findProjectConfigPath,
   getConfigPath,
   getManagedIndexPath,
+  getPluginCacheRoot,
+  getPluginDataRoot,
   getSkillsDir,
   homeDir,
   readJsonFile,
   sha256,
   writeJsonAtomic
-} from "./cli-zjepj3sj.js";
+} from "./cli-28g7x9rn.js";
 import {
+  __require,
   isServerEnabled
 } from "./cli-s4gspqdf.js";
 
-// src/core/config-store.ts
+// src/core/plugin-manager.ts
+import fs15 from "node:fs";
+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";
+var TMP_PREFIX = "mcpx-acquire-";
+
+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.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();
+      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();
+      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") {
+      throw new Error("npm source SHA resolution not yet implemented");
+    }
+    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.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], {
+          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"], {
+          cwd: tmpDir,
+          encoding: "utf8",
+          timeout: 1e4
+        }).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}`);
+          }
+          fs.renameSync(subdir, finalDest);
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+        } else {
+          fs.renameSync(tmpDir, 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") {
+      throw new Error("npm source fetch not yet implemented");
+    }
+    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 crypto = __require("node:crypto");
+  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/plugin-data.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+class PluginDataManager {
+  dataRoot;
+  constructor() {
+    this.dataRoot = getPluginDataRoot();
+    ensureDir(this.dataRoot);
+  }
+  getPluginDataDir(pluginId) {
+    return path2.join(this.dataRoot, pluginId);
+  }
+  getPluginDataPath(pluginId) {
+    return path2.join(this.getPluginDataDir(pluginId), "data.json");
+  }
+  async loadData(pluginId) {
+    const dataPath = this.getPluginDataPath(pluginId);
+    if (!fs2.existsSync(dataPath)) {
+      return null;
+    }
+    try {
+      const data = readJsonFile(dataPath, null);
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  async saveData(pluginId, data) {
+    const existing = await this.loadData(pluginId) || {};
+    const merged = { ...existing, ...data };
+    const dataPath = this.getPluginDataPath(pluginId);
+    ensureDir(path2.dirname(dataPath));
+    writeJsonAtomic(dataPath, merged);
+  }
+  async updateDependency(pluginId, packageName, version) {
+    const data = await this.loadData(pluginId);
+    if (!data) {
+      return;
+    }
+    if (!data.dependencies) {
+      data.dependencies = {};
+    }
+    data.dependencies[packageName] = version;
+    await this.saveData(pluginId, data);
+  }
+  async getDependencies(pluginId) {
+    const data = await this.loadData(pluginId);
+    return data?.dependencies || {};
+  }
+  async addLog(pluginId, level, message) {
+    const data = await this.loadData(pluginId);
+    if (!data) {
+      return;
+    }
+    if (!data.logs) {
+      data.logs = [];
+    }
+    data.logs.push({
+      timestamp: new Date().toISOString(),
+      level,
+      message
+    });
+    if (data.logs.length > 1000) {
+      data.logs = data.logs.slice(-1000);
+    }
+    await this.saveData(pluginId, data);
+  }
+  async updateStatus(pluginId, status, error) {
+    const data = await this.loadData(pluginId);
+    if (!data) {
+      return;
+    }
+    data.status = status;
+    if (error) {
+      data.error = error;
+    }
+    data.lastHealthCheck = new Date().toISOString();
+    await this.saveData(pluginId, data);
+  }
+  async removeData(pluginId) {
+    const dataDir = this.getPluginDataDir(pluginId);
+    if (fs2.existsSync(dataDir)) {
+      fs2.rmSync(dataDir, { recursive: true, force: true });
+    }
+  }
+  async cleanupOrphanedData() {
+    if (!fs2.existsSync(this.dataRoot)) {
+      return;
+    }
+    const pluginIds = fs2.readdirSync(this.dataRoot);
+    for (const pluginId of pluginIds) {
+      const pluginDir = path2.join(this.dataRoot, pluginId);
+      if (!fs2.statSync(pluginDir).isDirectory()) {
+        continue;
+      }
+      const dataPath = path2.join(pluginDir, "data.json");
+      if (!fs2.existsSync(dataPath)) {
+        fs2.rmSync(pluginDir, { recursive: true, force: true });
+      }
+    }
+  }
+}
+
+// src/core/plugin-lifecycle.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+class PluginLifecycle {
+  dataManager;
+  constructor() {
+    this.dataManager = new PluginDataManager;
+  }
+  async prepareDependencies(pluginId, pluginRoot) {
+    await this.dataManager.updateStatus(pluginId, "preparing");
+    const dataDir = path3.join(getPluginDataRoot(), pluginId);
+    ensureDir(dataDir);
+    const pkgJsonPath = path3.join(pluginRoot, "package.json");
+    if (fs3.existsSync(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (Object.keys(deps).length > 0) {
+          execFileSync2("npm", ["install", "--production"], {
+            cwd: pluginRoot,
+            stdio: "pipe",
+            timeout: 120000
+          });
+        }
+      } catch {}
+    }
+    const reqPath = path3.join(pluginRoot, "requirements.txt");
+    if (fs3.existsSync(reqPath)) {
+      try {
+        execFileSync2("pip", ["install", "-r", reqPath], {
+          stdio: "pipe",
+          timeout: 120000
+        });
+      } catch {}
+    }
+    await this.dataManager.updateStatus(pluginId, "healthy");
+  }
+  async removeData(pluginId) {
+    await this.dataManager.removeData(pluginId);
+  }
+  initData(pluginId) {
+    const dataDir = path3.join(getPluginDataRoot(), pluginId);
+    ensureDir(dataDir);
+    this.dataManager.saveData(pluginId, {
+      id: pluginId,
+      dependencies: {},
+      settings: {},
+      logs: [],
+      status: "healthy",
+      installedAt: new Date().toISOString()
+    });
+  }
+}
+
+// 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
+    };
+  }
+  return {
+    type: "git",
+    original: source
+  };
+}
+
+// src/core/plugin-parse.ts
+import fs4 from "node:fs";
+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 HOOKS_JSON_REL = path4.join("hooks", "hooks.json");
+var SKILLS_DIR = "skills";
+var COMMANDS_DIR = "commands";
+var AGENTS_DIR = "agents";
+var manifestSchema = z.object({
+  name: z.string().optional(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  source: z.string().optional(),
+  icon: z.string().optional(),
+  assets: z.array(z.string()).optional(),
+  entry: z.string().optional(),
+  author: z.object({ name: z.string(), email: z.string().optional(), url: z.string().optional() }).optional(),
+  homepage: z.string().optional(),
+  repository: z.string().optional(),
+  license: z.string().optional(),
+  keywords: z.array(z.string()).optional(),
+  category: z.string().optional(),
+  skills: z.union([z.string(), z.array(z.string())]).optional(),
+  commands: z.union([z.string(), z.array(z.string())]).optional(),
+  agents: z.union([z.string(), z.array(z.string())]).optional(),
+  hooks: z.unknown().optional(),
+  mcpServers: z.unknown().optional(),
+  lspServers: z.unknown().optional(),
+  apps: z.unknown().optional(),
+  settings: z.unknown().optional(),
+  outputStyles: z.unknown().optional(),
+  dependencies: z.unknown().optional(),
+  interface: z.object({
+    displayName: z.string().optional(),
+    shortDescription: z.string().optional(),
+    category: z.string().optional()
+  }).passthrough().optional()
+}).passthrough();
+function manifestPath(pluginRoot) {
+  for (const rel of [CLAUDE_PLUGIN_JSON_REL, CODEX_PLUGIN_JSON_REL]) {
+    const candidate = path4.join(pluginRoot, rel);
+    if (fs4.existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function readRawManifest(pluginRoot) {
+  const filePath = manifestPath(pluginRoot);
+  if (!filePath)
+    return null;
+  try {
+    return manifestSchema.parse(JSON.parse(fs4.readFileSync(filePath, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function sanitizeComponentId(id) {
+  const stripped = id.replace(/[\/\\]/g, "_").replace(/^\.+/, "");
+  return stripped.length > 0 ? stripped : "unnamed";
+}
+function readManifest(pluginRoot) {
+  const raw = readRawManifest(pluginRoot);
+  if (!raw)
+    return null;
+  const declaredCapabilities = ["skills", "commands", "agents", "hooks", "mcpServers", "lspServers", "apps", "settings", "outputStyles", "dependencies"].filter((key) => raw[key] !== undefined);
+  return {
+    name: raw.name ?? path4.basename(pluginRoot),
+    version: raw.version ?? "0.0.0",
+    description: raw.description ?? raw.interface?.shortDescription,
+    source: raw.source,
+    icon: raw.icon,
+    assets: raw.assets,
+    entry: raw.entry,
+    author: raw.author,
+    homepage: raw.homepage,
+    repository: raw.repository,
+    license: raw.license,
+    keywords: raw.keywords,
+    displayName: raw.interface?.displayName,
+    category: raw.category ?? raw.interface?.category,
+    declaredCapabilities
+  };
+}
+function declaredPaths(raw, key, fallback) {
+  const value = raw?.[key];
+  if (typeof value === "string")
+    return [value];
+  if (Array.isArray(value))
+    return value;
+  return [fallback];
+}
+function resolveWithinRoot(pluginRoot, declared) {
+  const resolved = path4.resolve(pluginRoot, declared);
+  const root = path4.resolve(pluginRoot);
+  return resolved === root || resolved.startsWith(root + path4.sep) ? resolved : null;
+}
+function parseFrontmatter(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { frontmatter: {}, body: content };
+  }
+  const end = trimmed.indexOf("---", 3);
+  if (end === -1) {
+    return { frontmatter: {}, body: content };
+  }
+  const raw = trimmed.slice(3, end).trim();
+  const body = trimmed.slice(end + 3).trimStart();
+  const frontmatter = {};
+  for (const line of raw.split(`
+`)) {
+    const sep = line.indexOf(":");
+    if (sep !== -1) {
+      const key = line.slice(0, sep).trim();
+      const val = line.slice(sep + 1).trim();
+      if (key === "name")
+        frontmatter.name = val;
+      if (key === "description")
+        frontmatter.description = val;
+    }
+  }
+  return { frontmatter, body };
+}
+function discoverSkills(pluginRoot, raw) {
+  const results = [];
+  for (const declared of declaredPaths(raw, "skills", SKILLS_DIR))
+    try {
+      const skillsDir = resolveWithinRoot(pluginRoot, declared);
+      if (!skillsDir || !fs4.existsSync(skillsDir))
+        continue;
+      const entries = fs4.readdirSync(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) {
+          if (entry.name.endsWith(".md")) {
+            const skillPath = path4.join(skillsDir, entry.name);
+            const content = fs4.readFileSync(skillPath, "utf8");
+            const { frontmatter } = parseFrontmatter(content);
+            results.push({
+              id: sanitizeComponentId(frontmatter.name ?? path4.basename(entry.name, ".md")),
+              type: "skills",
+              path: skillPath,
+              description: frontmatter.description
+            });
+          }
+          continue;
+        }
+        const skillMdPath = path4.join(skillsDir, entry.name, "SKILL.md");
+        if (fs4.existsSync(skillMdPath)) {
+          const content = fs4.readFileSync(skillMdPath, "utf8");
+          const { frontmatter } = parseFrontmatter(content);
+          results.push({
+            id: sanitizeComponentId(frontmatter.name ?? entry.name),
+            type: "skills",
+            path: skillMdPath,
+            description: frontmatter.description
+          });
+        }
+      }
+    } catch {}
+  return results;
+}
+function discoverCommands(pluginRoot, raw) {
+  const results = [];
+  for (const declared of declaredPaths(raw, "commands", COMMANDS_DIR))
+    try {
+      const commandsDir = resolveWithinRoot(pluginRoot, declared);
+      if (!commandsDir || !fs4.existsSync(commandsDir))
+        continue;
+      const entries = fs4.readdirSync(commandsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          const cmdPath = path4.join(commandsDir, entry.name);
+          const content = fs4.readFileSync(cmdPath, "utf8");
+          const { frontmatter } = parseFrontmatter(content);
+          results.push({
+            id: sanitizeComponentId(frontmatter.name ?? path4.basename(entry.name, ".md")),
+            type: "commands",
+            path: cmdPath,
+            description: frontmatter.description
+          });
+        }
+      }
+    } catch {}
+  return results;
+}
+function discoverAgents(pluginRoot, raw) {
+  const results = [];
+  for (const declared of declaredPaths(raw, "agents", AGENTS_DIR))
+    try {
+      const agentsDir = resolveWithinRoot(pluginRoot, declared);
+      if (!agentsDir || !fs4.existsSync(agentsDir))
+        continue;
+      const entries = fs4.readdirSync(agentsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          const agentPath = path4.join(agentsDir, entry.name);
+          const content = fs4.readFileSync(agentPath, "utf8");
+          const { frontmatter } = parseFrontmatter(content);
+          results.push({
+            id: sanitizeComponentId(frontmatter.name ?? path4.basename(entry.name, ".md")),
+            type: "agents",
+            path: agentPath,
+            description: frontmatter.description
+          });
+        }
+      }
+    } catch {}
+  return results;
+}
+function discoverHooks(pluginRoot, raw) {
+  const declared = typeof raw?.hooks === "string" ? raw.hooks : undefined;
+  const hooksPath = declared ? resolveWithinRoot(pluginRoot, declared) : [path4.join(pluginRoot, HOOKS_JSON_REL), path4.join(pluginRoot, "hooks.json")].find(fs4.existsSync) ?? null;
+  if (!hooksPath || !fs4.existsSync(hooksPath))
+    return [];
+  try {
+    const raw2 = JSON.parse(fs4.readFileSync(hooksPath, "utf8"));
+    const hooks = Array.isArray(raw2) ? raw2 : raw2.hooks ?? [];
+    return hooks.map((h, i) => ({
+      id: h.id ?? `hook-${i}`,
+      type: "hooks",
+      path: hooksPath,
+      description: h.description
+    }));
+  } catch {
+    return [];
+  }
+}
+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);
+  if (!mcpPath || !fs4.existsSync(mcpPath))
+    return [];
+  try {
+    const raw2 = JSON.parse(fs4.readFileSync(mcpPath, "utf8"));
+    const servers = raw2.mcpServers ?? {};
+    return Object.entries(servers).map(([id, s]) => {
+      const isHttp = s.type === "http" || typeof s.url === "string";
+      return {
+        id,
+        transport: isHttp ? "http" : "stdio",
+        command: s.command ?? "",
+        args: s.args,
+        env: s.env,
+        cwd: s.cwd,
+        url: isHttp ? s.url : undefined,
+        oauthResource: s.oauth_resource
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function discoverComponents(pluginRoot) {
+  const raw = readRawManifest(pluginRoot);
+  return {
+    skills: discoverSkills(pluginRoot, raw),
+    commands: discoverCommands(pluginRoot, raw),
+    agents: discoverAgents(pluginRoot, raw),
+    hooks: discoverHooks(pluginRoot, raw),
+    mcpServers: discoverMcpServers(pluginRoot, raw)
+  };
+}
+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);
+}
+
+// src/core/config-store.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
 var LOCK_STALE_MS = 5000;
 var LOCK_RETRY_MS = 50;
 var LOCK_MAX_RETRIES = 40;
@@ -35,19 +740,19 @@ function getLockPath(filePath) {
 function acquireLock(filePath) {
   const lockPath = getLockPath(filePath);
   try {
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-    const fd = fs.openSync(lockPath, "wx");
-    fs.writeSync(fd, String(process.pid));
-    fs.closeSync(fd);
+    fs5.mkdirSync(path5.dirname(lockPath), { recursive: true });
+    const fd = fs5.openSync(lockPath, "wx");
+    fs5.writeSync(fd, String(process.pid));
+    fs5.closeSync(fd);
     return true;
   } catch (err) {
     if (err.code !== "EEXIST") {
       return false;
     }
     try {
-      const stat = fs.statSync(lockPath);
+      const stat = fs5.statSync(lockPath);
       if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-        fs.unlinkSync(lockPath);
+        fs5.unlinkSync(lockPath);
         return acquireLock(filePath);
       }
     } catch {
@@ -58,7 +763,7 @@ function acquireLock(filePath) {
 }
 function releaseLock(filePath) {
   try {
-    fs.unlinkSync(getLockPath(filePath));
+    fs5.unlinkSync(getLockPath(filePath));
   } catch {}
 }
 function mutateFile(filePath, load, save, fn) {
@@ -100,8 +805,8 @@ async function mutateActiveConfig(options, mutator) {
   if (!options.global) {
     const projectConfigPath = findProjectConfigPath();
     if (options.local) {
-      const projectPath = projectConfigPath ? path.dirname(projectConfigPath) : process.cwd();
-      const localPath = path.join(projectPath, ".mcpx.json");
+      const projectPath = projectConfigPath ? path5.dirname(projectConfigPath) : process.cwd();
+      const localPath = path5.join(projectPath, ".mcpx.json");
       const globalConfig = loadConfig(globalPath);
       const result2 = await mutateProjectConfig(localPath, async (projectConfig) => {
         const mergedConfig = {
@@ -121,7 +826,7 @@ async function mutateActiveConfig(options, mutator) {
       return { type: "project", configPath: localPath, projectPath, result: result2 };
     }
     if (projectConfigPath) {
-      const projectPath = path.dirname(projectConfigPath);
+      const projectPath = path5.dirname(projectConfigPath);
       const result2 = await mutateConfig((config) => mutator(config, { type: "project", projectPath }), globalPath);
       return { type: "project", configPath: globalPath, projectPath, result: result2 };
     }
@@ -130,67 +835,189 @@ async function mutateActiveConfig(options, mutator) {
   return { type: "global", configPath: globalPath, result };
 }
 
-// src/core/skills.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
-function listSkills() {
-  const skillsDir = getSkillsDir();
-  if (!fs2.existsSync(skillsDir)) {
-    return [];
+// src/adapters/utils/index.ts
+function getManagedEntryNames(managedIndex, clientId) {
+  return Object.keys(managedIndex.managed[clientId]?.entries ?? {});
+}
+function isManagedEntry(managedIndex, clientId, entryName) {
+  return Boolean(managedIndex.managed[clientId]?.entries?.[entryName]);
+}
+function pruneStaleManagedEntries(managedIndex, clientId, servers, keepEntryNames) {
+  const keep = new Set(keepEntryNames);
+  const managedNames = getManagedEntryNames(managedIndex, clientId);
+  for (const name of managedNames) {
+    if (!keep.has(name)) {
+      delete servers[name];
+    }
   }
-  const files = fs2.readdirSync(skillsDir);
-  const skills = [];
-  for (const file of files) {
-    if (file.endsWith(".md")) {
-      const id = path2.basename(file, ".md");
-      const content = fs2.readFileSync(path2.join(skillsDir, file), "utf-8");
-      skills.push({ id, content });
+  for (const name of Object.keys(servers)) {
+    if (!keep.has(name) && name.endsWith(" (mcpx)")) {
+      delete servers[name];
+    }
+  }
+}
+function ensureManagedEntryWritable(managedIndex, clientId, entryName, existingValue, expectedEntry) {
+  if (existingValue === undefined || existingValue === null) {
+    return null;
+  }
+  if (isManagedEntry(managedIndex, clientId, entryName)) {
+    return null;
+  }
+  if (expectedEntry && isManagedGatewayProjection(entryName) && matchesExpectedShape(existingValue, expectedEntry)) {
+    if (!managedIndex.managed[clientId]) {
+      managedIndex.managed[clientId] = { configPath: "", entries: {} };
     }
+    managedIndex.managed[clientId].entries[entryName] = {
+      fingerprint: sha256(JSON.stringify(existingValue)),
+      lastSyncedAt: new Date().toISOString()
+    };
+    return null;
+  }
+  return `Cannot sync managed entry "${entryName}" because an unmanaged entry already exists.`;
+}
+function matchesExpectedShape(value, expected) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  if (expected.url && v.url !== expected.url)
+    return false;
+  if (expected.command && v.command !== expected.command)
+    return false;
+  return true;
+}
+function setManagedEntries(managedIndex, clientId, configPath, entries) {
+  if (!managedIndex.managed[clientId]) {
+    managedIndex.managed[clientId] = {
+      configPath,
+      entries: {}
+    };
+  }
+  managedIndex.managed[clientId].configPath = configPath;
+  managedIndex.managed[clientId].entries = Object.fromEntries(Object.entries(entries).map(([entryName, serializedEntry]) => [entryName, {
+    fingerprint: sha256(serializedEntry),
+    lastSyncedAt: new Date().toISOString()
+  }]));
+}
+function okResult(clientId, configPath, message) {
+  return {
+    clientId,
+    status: "SYNCED",
+    configPath,
+    message
+  };
+}
+function errorResult(clientId, configPath, message) {
+  return {
+    clientId,
+    status: "ERROR",
+    configPath,
+    message
+  };
+}
+function managedGatewayEntryName(serverName) {
+  return `${serverName} (mcpx)`;
+}
+function isManagedGatewayProjection(entryName) {
+  return entryName.endsWith(" (mcpx)");
+}
+function sortRecord(record) {
+  if (!record || Object.keys(record).length === 0) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}
+function normalizeServerSpec(spec) {
+  if (spec.transport === "http") {
+    return {
+      transport: "http",
+      url: spec.url,
+      headers: sortRecord(spec.headers)
+    };
   }
-  return skills;
+  return {
+    transport: "stdio",
+    command: spec.command,
+    args: spec.args && spec.args.length > 0 ? [...spec.args] : undefined,
+    env: sortRecord(spec.env),
+    cwd: spec.cwd
+  };
 }
-function getSkill(id) {
-  const skillsDir = getSkillsDir();
-  const filePath = path2.join(skillsDir, `${id}.md`);
-  if (!fs2.existsSync(filePath)) {
-    return null;
+function serializeServerSpec(spec) {
+  return JSON.stringify(normalizeServerSpec(spec));
+}
+function serverSpecsEqual(left, right) {
+  return serializeServerSpec(left) === serializeServerSpec(right);
+}
+function emptyImportScan(clientId, configPath) {
+  return {
+    clientId,
+    configPath,
+    candidates: [],
+    skipped: []
+  };
+}
+function buildImportSkip(clientId, sourceEntryName, reason, configPath, serverName = sourceEntryName) {
+  return {
+    clientId,
+    configPath,
+    sourceEntryName,
+    serverName,
+    reason
+  };
+}
+function removeSourceEntries(entries, names) {
+  for (const name of names ?? []) {
+    delete entries[name];
   }
-  const content = fs2.readFileSync(filePath, "utf-8");
-  return { id, content };
 }
-function saveSkill(id, content) {
-  const skillsDir = getSkillsDir();
-  ensureDir(skillsDir);
-  const filePath = path2.join(skillsDir, `${id}.md`);
-  fs2.writeFileSync(filePath, content, "utf-8");
+function purgeManagedFromDisabledArray(raw, managedNames) {
+  const existingDisabled = raw.disabledMcpServers ?? [];
+  raw.disabledMcpServers = existingDisabled.filter((name) => !managedNames.includes(name));
+  if (Array.isArray(raw.disabledMcpServers) && raw.disabledMcpServers.length === 0) {
+    delete raw.disabledMcpServers;
+  }
 }
-function deleteSkill(id) {
-  const skillsDir = getSkillsDir();
-  const filePath = path2.join(skillsDir, `${id}.md`);
-  if (fs2.existsSync(filePath)) {
-    fs2.unlinkSync(filePath);
+function purgeManagedFromExcludedArray(raw, managedNames) {
+  const mcp = raw.mcp ?? {};
+  const existingExcluded = mcp.excluded ?? [];
+  mcp.excluded = existingExcluded.filter((name) => !managedNames.includes(name));
+  if (Array.isArray(mcp.excluded) && mcp.excluded.length === 0) {
+    delete mcp.excluded;
   }
+  raw.mcp = Object.keys(mcp).length > 0 ? mcp : undefined;
+}
+function detectManagedEntryDrift(managedIndex, clientId, entryName, existingValue) {
+  const recorded = managedIndex.managed[clientId]?.entries?.[entryName];
+  if (!recorded || existingValue === undefined)
+    return false;
+  const liveFingerprint = sha256(JSON.stringify(existingValue));
+  return liveFingerprint !== recorded.fingerprint;
 }
 
+// src/adapters/claude.ts
+import fs8 from "node:fs";
+import path8 from "node:path";
+import { z as z2 } from "zod";
+
 // src/core/plugin-projections.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs6 from "node:fs";
+import path6 from "node:path";
 var OWNERSHIP_MANIFEST = "mcpx-plugins.json";
 function loadOwnership(targetDir) {
-  const manifestPath = path3.join(targetDir, OWNERSHIP_MANIFEST);
-  if (!fs3.existsSync(manifestPath)) {
+  const manifestPath2 = path6.join(targetDir, OWNERSHIP_MANIFEST);
+  if (!fs6.existsSync(manifestPath2)) {
     return { version: 1, plugins: {} };
   }
   try {
-    return JSON.parse(fs3.readFileSync(manifestPath, "utf8"));
+    return JSON.parse(fs6.readFileSync(manifestPath2, "utf8"));
   } catch {
-    console.error(`[mcpx] Warning: corrupt plugin ownership manifest at ${manifestPath}, resetting`);
+    console.error(`[mcpx] Warning: corrupt plugin ownership manifest at ${manifestPath2}, resetting`);
     return { version: 1, plugins: {} };
   }
 }
 function saveOwnership(targetDir, manifest) {
   ensureDir(targetDir);
-  fs3.writeFileSync(path3.join(targetDir, OWNERSHIP_MANIFEST), JSON.stringify(manifest, null, 2));
+  fs6.writeFileSync(path6.join(targetDir, OWNERSHIP_MANIFEST), JSON.stringify(manifest, null, 2));
 }
 function recordOwned(targetDir, pluginId, paths) {
   const manifest = loadOwnership(targetDir);
@@ -214,10 +1041,10 @@ function removeOwned(targetDir, pluginId) {
 function prunePluginProjections(targetDir, pluginId) {
   const paths = removeOwned(targetDir, pluginId);
   for (const p of paths) {
-    const fullPath = path3.join(targetDir, p);
+    const fullPath = path6.join(targetDir, p);
     try {
-      if (fs3.existsSync(fullPath)) {
-        fs3.rmSync(fullPath, { recursive: true, force: true });
+      if (fs6.existsSync(fullPath)) {
+        fs6.rmSync(fullPath, { recursive: true, force: true });
       }
     } catch {}
   }
@@ -241,9 +1068,9 @@ function nsName(pluginName, id) {
   return `${pluginName}__${id}`;
 }
 function assertWithinBase(base, target) {
-  const resolvedBase = path3.resolve(base);
-  const resolvedTarget = path3.resolve(target);
-  if (resolvedTarget !== resolvedBase && !resolvedTarget.startsWith(resolvedBase + path3.sep)) {
+  const resolvedBase = path6.resolve(base);
+  const resolvedTarget = path6.resolve(target);
+  if (resolvedTarget !== resolvedBase && !resolvedTarget.startsWith(resolvedBase + path6.sep)) {
     throw new Error(`Refusing to write outside projection base: ${target} (base: ${base})`);
   }
 }
@@ -260,7 +1087,7 @@ function isComponentApproved(plugin, component) {
   return plugin.components[component] ?? false;
 }
 function syncClaude(plugins) {
-  const targetBase = path3.join(homeDir(), ".claude", "skills");
+  const targetBase = path6.join(homeDir(), ".claude", "skills");
   const projectedDirs = [];
   const unsupported = [];
   const skippedUnapproved = [];
@@ -271,13 +1098,13 @@ function syncClaude(plugins) {
       skippedUnapproved.push(`${plugin.pluginName}:skills`);
       continue;
     }
-    const targetDir = path3.join(targetBase, plugin.pluginName);
+    const targetDir = path6.join(targetBase, plugin.pluginName);
     ensureDir(targetDir);
-    const mcpJsonSrc = path3.join(plugin.pluginRoot, ".mcp.json");
-    const mcpJsonDest = path3.join(targetDir, ".mcp.json");
+    const mcpJsonSrc = path6.join(plugin.pluginRoot, ".mcp.json");
+    const mcpJsonDest = path6.join(targetDir, ".mcp.json");
     copyPluginDir(plugin.pluginRoot, targetDir, [".mcp.json", ".git"]);
-    if (fs3.existsSync(mcpJsonDest)) {
-      fs3.rmSync(mcpJsonDest, { recursive: true, force: true });
+    if (fs6.existsSync(mcpJsonDest)) {
+      fs6.rmSync(mcpJsonDest, { recursive: true, force: true });
     }
     projectedDirs.push(targetDir);
     recordOwned(targetBase, plugin.pluginId, [plugin.pluginName]);
@@ -299,7 +1126,7 @@ function syncClaudeDesktop(plugins) {
   };
 }
 function syncCodex(plugins) {
-  const targetBase = path3.join(homeDir(), ".codex", "skills");
+  const targetBase = path6.join(homeDir(), ".codex", "skills");
   const projectedDirs = [];
   const unsupported = ["hooks", "agents"];
   const errors = [];
@@ -311,10 +1138,10 @@ function syncCodex(plugins) {
       const owned = [];
       for (const skill of plugin.skills) {
         try {
-          const targetDir = path3.join(targetBase, nsName(plugin.pluginName, skill.id));
+          const targetDir = path6.join(targetBase, nsName(plugin.pluginName, skill.id));
           assertWithinBase(targetBase, targetDir);
           ensureDir(targetDir);
-          copyFileOrDir(skill.path, path3.join(targetDir, "SKILL.md"));
+          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
           owned.push(nsName(plugin.pluginName, skill.id));
           projectedDirs.push(targetDir);
         } catch (error) {
@@ -333,8 +1160,8 @@ function syncCodex(plugins) {
   };
 }
 function syncCursor(plugins) {
-  const skillsBase = path3.join(homeDir(), ".cursor", "skills");
-  const commandsBase = path3.join(homeDir(), ".cursor", "commands");
+  const skillsBase = path6.join(homeDir(), ".cursor", "skills");
+  const commandsBase = path6.join(homeDir(), ".cursor", "commands");
   const projectedDirs = [];
   const unsupported = ["hooks", "agents"];
   const errors = [];
@@ -347,10 +1174,10 @@ function syncCursor(plugins) {
       ensureDir(skillsBase);
       for (const skill of plugin.skills) {
         try {
-          const targetDir = path3.join(skillsBase, nsName(plugin.pluginName, skill.id));
+          const targetDir = path6.join(skillsBase, nsName(plugin.pluginName, skill.id));
           assertWithinBase(skillsBase, targetDir);
           ensureDir(targetDir);
-          copyFileOrDir(skill.path, path3.join(targetDir, "SKILL.md"));
+          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
           ownedSkills.push(nsName(plugin.pluginName, skill.id));
           projectedDirs.push(targetDir);
         } catch (error) {
@@ -362,7 +1189,7 @@ function syncCursor(plugins) {
       ensureDir(commandsBase);
       for (const cmd of plugin.commands) {
         try {
-          const targetPath = path3.join(commandsBase, `${nsName(plugin.pluginName, cmd.id)}.md`);
+          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`);
@@ -386,7 +1213,7 @@ function syncCursor(plugins) {
   };
 }
 function syncVsCode(plugins) {
-  const skillsBase = path3.join(homeDir(), ".copilot", "skills");
+  const skillsBase = path6.join(homeDir(), ".copilot", "skills");
   const projectedDirs = [];
   const unsupported = ["hooks", "agents"];
   const errors = [];
@@ -398,10 +1225,10 @@ function syncVsCode(plugins) {
       const owned = [];
       for (const skill of plugin.skills) {
         try {
-          const targetDir = path3.join(skillsBase, nsName(plugin.pluginName, skill.id));
+          const targetDir = path6.join(skillsBase, nsName(plugin.pluginName, skill.id));
           assertWithinBase(skillsBase, targetDir);
           ensureDir(targetDir);
-          copyFileOrDir(skill.path, path3.join(targetDir, "SKILL.md"));
+          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
           owned.push(nsName(plugin.pluginName, skill.id));
           projectedDirs.push(targetDir);
         } catch (error) {
@@ -420,7 +1247,7 @@ function syncVsCode(plugins) {
   };
 }
 function syncQwen(plugins) {
-  const targetBase = path3.join(homeDir(), ".qwen", "skills");
+  const targetBase = path6.join(homeDir(), ".qwen", "skills");
   const projectedDirs = [];
   const unsupported = ["hooks", "agents", "commands"];
   const errors = [];
@@ -432,10 +1259,10 @@ function syncQwen(plugins) {
       const owned = [];
       for (const skill of plugin.skills) {
         try {
-          const targetDir = path3.join(targetBase, nsName(plugin.pluginName, skill.id));
+          const targetDir = path6.join(targetBase, nsName(plugin.pluginName, skill.id));
           assertWithinBase(targetBase, targetDir);
           ensureDir(targetDir);
-          copyFileOrDir(skill.path, path3.join(targetDir, "SKILL.md"));
+          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
           owned.push(nsName(plugin.pluginName, skill.id));
           projectedDirs.push(targetDir);
         } catch (error) {
@@ -454,7 +1281,7 @@ function syncQwen(plugins) {
   };
 }
 function syncCline(plugins) {
-  const targetBase = path3.join(homeDir(), ".config", "cline", "skills");
+  const targetBase = path6.join(homeDir(), ".config", "cline", "skills");
   const projectedDirs = [];
   const unsupported = ["hooks", "agents", "commands"];
   const errors = [];
@@ -466,10 +1293,10 @@ function syncCline(plugins) {
       const owned = [];
       for (const skill of plugin.skills) {
         try {
-          const targetDir = path3.join(targetBase, nsName(plugin.pluginName, skill.id));
+          const targetDir = path6.join(targetBase, nsName(plugin.pluginName, skill.id));
           assertWithinBase(targetBase, targetDir);
           ensureDir(targetDir);
-          copyFileOrDir(skill.path, path3.join(targetDir, "SKILL.md"));
+          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
           owned.push(nsName(plugin.pluginName, skill.id));
           projectedDirs.push(targetDir);
         } catch (error) {
@@ -488,7 +1315,7 @@ function syncCline(plugins) {
   };
 }
 function syncKiro(plugins) {
-  const targetBase = path3.join(homeDir(), ".kiro", "skills");
+  const targetBase = path6.join(homeDir(), ".kiro", "skills");
   const projectedDirs = [];
   const unsupported = ["hooks", "agents", "commands"];
   const errors = [];
@@ -500,10 +1327,10 @@ function syncKiro(plugins) {
       const owned = [];
       for (const skill of plugin.skills) {
         try {
-          const targetDir = path3.join(targetBase, nsName(plugin.pluginName, skill.id));
+          const targetDir = path6.join(targetBase, nsName(plugin.pluginName, skill.id));
           assertWithinBase(targetBase, targetDir);
           ensureDir(targetDir);
-          copyFileOrDir(skill.path, path3.join(targetDir, "SKILL.md"));
+          copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
           owned.push(nsName(plugin.pluginName, skill.id));
           projectedDirs.push(targetDir);
         } catch (error) {
@@ -547,14 +1374,14 @@ function syncPluginsToClient(clientId, plugins) {
     return { clientId, status: "SKIPPED", projectedDirs: [], unsupported: [] };
   }
   const targetBaseMap = {
-    claude: path3.join(homeDir(), ".claude", "skills"),
+    claude: path6.join(homeDir(), ".claude", "skills"),
     "claude-desktop": "",
-    codex: path3.join(homeDir(), ".codex", "skills"),
-    cursor: path3.join(homeDir(), ".cursor"),
-    vscode: path3.join(homeDir(), ".copilot", "skills"),
-    qwen: path3.join(homeDir(), ".qwen", "skills"),
-    cline: path3.join(homeDir(), ".config", "cline", "skills"),
-    kiro: path3.join(homeDir(), ".kiro", "skills"),
+    codex: path6.join(homeDir(), ".codex", "skills"),
+    cursor: path6.join(homeDir(), ".cursor"),
+    vscode: path6.join(homeDir(), ".copilot", "skills"),
+    qwen: path6.join(homeDir(), ".qwen", "skills"),
+    cline: path6.join(homeDir(), ".config", "cline", "skills"),
+    kiro: path6.join(homeDir(), ".kiro", "skills"),
     opencode: ""
   };
   const target = targetBaseMap[clientId];
@@ -567,17 +1394,17 @@ function syncPluginsToClient(clientId, plugins) {
 function copyPluginDir(src, dest, exclude = [], errors) {
   const excludeSet = new Set(exclude);
   ensureDir(dest);
-  const entries = fs3.readdirSync(src, { withFileTypes: true });
+  const entries = fs6.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
     if (excludeSet.has(entry.name))
       continue;
-    const srcPath = path3.join(src, entry.name);
-    const destPath = path3.join(dest, entry.name);
+    const srcPath = path6.join(src, entry.name);
+    const destPath = path6.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyPluginDir(srcPath, destPath, exclude, errors);
     } else if (entry.isFile()) {
       try {
-        fs3.copyFileSync(srcPath, destPath);
+        fs6.copyFileSync(srcPath, destPath);
       } catch (e) {
         errors?.push(`Failed to copy ${srcPath}: ${e.message}`);
       }
@@ -586,242 +1413,75 @@ function copyPluginDir(src, dest, exclude = [], errors) {
 }
 function copyFileOrDir(src, dest, errors) {
   try {
-    ensureDir(path3.dirname(dest));
-    if (fs3.statSync(src).isDirectory()) {
+    ensureDir(path6.dirname(dest));
+    if (fs6.statSync(src).isDirectory()) {
       copyPluginDir(src, dest, [], errors);
     } else {
-      fs3.copyFileSync(src, dest);
+      fs6.copyFileSync(src, dest);
     }
   } catch (e) {
     errors?.push(`Failed to copy ${src} -> ${dest}: ${e.message}`);
   }
 }
 
-// src/version.ts
-var APP_VERSION = "0.1.3";
-
-// src/adapters/claude.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
-import { z } from "zod";
-
 // src/core/skill-projections.ts
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs7 from "node:fs";
+import path7 from "node:path";
 var OWNERSHIP_MANIFEST2 = "mcpx-skills.json";
 function loadOwnership2(targetDir) {
-  const manifestPath = path4.join(targetDir, OWNERSHIP_MANIFEST2);
-  if (!fs4.existsSync(manifestPath)) {
-    return { version: 1, paths: [] };
-  }
-  try {
-    return JSON.parse(fs4.readFileSync(manifestPath, "utf8"));
-  } catch {
-    console.error(`[mcpx] Warning: corrupt ownership manifest at ${manifestPath}, resetting`);
-    return { version: 1, paths: [] };
-  }
-}
-function saveOwnership2(targetDir, manifest) {
-  ensureDir(targetDir);
-  fs4.writeFileSync(path4.join(targetDir, OWNERSHIP_MANIFEST2), JSON.stringify(manifest, null, 2));
-}
-function projectSkillsToDir(targetDir, skills, layout) {
-  const owned = loadOwnership2(targetDir);
-  const newPaths = new Set(skills.map((s) => layout === "dir" ? `${s.id}/SKILL.md` : `${s.id}.md`));
-  for (const ownedPath of owned.paths) {
-    if (!newPaths.has(ownedPath)) {
-      const fullPath = path4.join(targetDir, ownedPath);
-      try {
-        if (fs4.existsSync(fullPath)) {
-          fs4.rmSync(fullPath, { recursive: true, force: true });
-        }
-        if (layout === "dir") {
-          const dirPath = path4.join(targetDir, path4.dirname(ownedPath));
-          try {
-            const remaining = fs4.readdirSync(dirPath);
-            if (remaining.length === 0) {
-              fs4.rmSync(dirPath, { recursive: true, force: true });
-            }
-          } catch {}
-        }
-      } catch {
-        console.error(`[mcpx] Warning: could not remove stale skill projection: ${fullPath}`);
-      }
-    }
-  }
-  for (const skill of skills) {
-    const filePath = layout === "dir" ? path4.join(targetDir, skill.id, "SKILL.md") : path4.join(targetDir, `${skill.id}.md`);
-    ensureDir(path4.dirname(filePath));
-    fs4.writeFileSync(filePath, skill.content, "utf-8");
-  }
-  saveOwnership2(targetDir, { version: 1, paths: Array.from(newPaths) });
-}
-
-// src/adapters/utils/index.ts
-function getManagedEntryNames(managedIndex, clientId) {
-  return Object.keys(managedIndex.managed[clientId]?.entries ?? {});
-}
-function isManagedEntry(managedIndex, clientId, entryName) {
-  return Boolean(managedIndex.managed[clientId]?.entries?.[entryName]);
-}
-function pruneStaleManagedEntries(managedIndex, clientId, servers, keepEntryNames) {
-  const keep = new Set(keepEntryNames);
-  const managedNames = getManagedEntryNames(managedIndex, clientId);
-  for (const name of managedNames) {
-    if (!keep.has(name)) {
-      delete servers[name];
-    }
-  }
-  for (const name of Object.keys(servers)) {
-    if (!keep.has(name) && name.endsWith(" (mcpx)")) {
-      delete servers[name];
-    }
-  }
-}
-function ensureManagedEntryWritable(managedIndex, clientId, entryName, existingValue, expectedEntry) {
-  if (existingValue === undefined || existingValue === null) {
-    return null;
-  }
-  if (isManagedEntry(managedIndex, clientId, entryName)) {
-    return null;
-  }
-  if (expectedEntry && isManagedGatewayProjection(entryName) && matchesExpectedShape(existingValue, expectedEntry)) {
-    if (!managedIndex.managed[clientId]) {
-      managedIndex.managed[clientId] = { configPath: "", entries: {} };
-    }
-    managedIndex.managed[clientId].entries[entryName] = {
-      fingerprint: sha256(JSON.stringify(existingValue)),
-      lastSyncedAt: new Date().toISOString()
-    };
-    return null;
-  }
-  return `Cannot sync managed entry "${entryName}" because an unmanaged entry already exists.`;
-}
-function matchesExpectedShape(value, expected) {
-  if (!value || typeof value !== "object")
-    return false;
-  const v = value;
-  if (expected.url && v.url !== expected.url)
-    return false;
-  if (expected.command && v.command !== expected.command)
-    return false;
-  return true;
-}
-function setManagedEntries(managedIndex, clientId, configPath, entries) {
-  if (!managedIndex.managed[clientId]) {
-    managedIndex.managed[clientId] = {
-      configPath,
-      entries: {}
-    };
-  }
-  managedIndex.managed[clientId].configPath = configPath;
-  managedIndex.managed[clientId].entries = Object.fromEntries(Object.entries(entries).map(([entryName, serializedEntry]) => [entryName, {
-    fingerprint: sha256(serializedEntry),
-    lastSyncedAt: new Date().toISOString()
-  }]));
-}
-function okResult(clientId, configPath, message) {
-  return {
-    clientId,
-    status: "SYNCED",
-    configPath,
-    message
-  };
-}
-function errorResult(clientId, configPath, message) {
-  return {
-    clientId,
-    status: "ERROR",
-    configPath,
-    message
-  };
-}
-function managedGatewayEntryName(serverName) {
-  return `${serverName} (mcpx)`;
-}
-function isManagedGatewayProjection(entryName) {
-  return entryName.endsWith(" (mcpx)");
-}
-function sortRecord(record) {
-  if (!record || Object.keys(record).length === 0) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
-}
-function normalizeServerSpec(spec) {
-  if (spec.transport === "http") {
-    return {
-      transport: "http",
-      url: spec.url,
-      headers: sortRecord(spec.headers)
-    };
-  }
-  return {
-    transport: "stdio",
-    command: spec.command,
-    args: spec.args && spec.args.length > 0 ? [...spec.args] : undefined,
-    env: sortRecord(spec.env),
-    cwd: spec.cwd
-  };
-}
-function serializeServerSpec(spec) {
-  return JSON.stringify(normalizeServerSpec(spec));
-}
-function serverSpecsEqual(left, right) {
-  return serializeServerSpec(left) === serializeServerSpec(right);
-}
-function emptyImportScan(clientId, configPath) {
-  return {
-    clientId,
-    configPath,
-    candidates: [],
-    skipped: []
-  };
-}
-function buildImportSkip(clientId, sourceEntryName, reason, configPath, serverName = sourceEntryName) {
-  return {
-    clientId,
-    configPath,
-    sourceEntryName,
-    serverName,
-    reason
-  };
-}
-function removeSourceEntries(entries, names) {
-  for (const name of names ?? []) {
-    delete entries[name];
+  const manifestPath2 = path7.join(targetDir, OWNERSHIP_MANIFEST2);
+  if (!fs7.existsSync(manifestPath2)) {
+    return { version: 1, paths: [] };
   }
-}
-function purgeManagedFromDisabledArray(raw, managedNames) {
-  const existingDisabled = raw.disabledMcpServers ?? [];
-  raw.disabledMcpServers = existingDisabled.filter((name) => !managedNames.includes(name));
-  if (Array.isArray(raw.disabledMcpServers) && raw.disabledMcpServers.length === 0) {
-    delete raw.disabledMcpServers;
+  try {
+    return JSON.parse(fs7.readFileSync(manifestPath2, "utf8"));
+  } catch {
+    console.error(`[mcpx] Warning: corrupt ownership manifest at ${manifestPath2}, resetting`);
+    return { version: 1, paths: [] };
   }
 }
-function purgeManagedFromExcludedArray(raw, managedNames) {
-  const mcp = raw.mcp ?? {};
-  const existingExcluded = mcp.excluded ?? [];
-  mcp.excluded = existingExcluded.filter((name) => !managedNames.includes(name));
-  if (Array.isArray(mcp.excluded) && mcp.excluded.length === 0) {
-    delete mcp.excluded;
-  }
-  raw.mcp = Object.keys(mcp).length > 0 ? mcp : undefined;
+function saveOwnership2(targetDir, manifest) {
+  ensureDir(targetDir);
+  fs7.writeFileSync(path7.join(targetDir, OWNERSHIP_MANIFEST2), JSON.stringify(manifest, null, 2));
 }
-function detectManagedEntryDrift(managedIndex, clientId, entryName, existingValue) {
-  const recorded = managedIndex.managed[clientId]?.entries?.[entryName];
-  if (!recorded || existingValue === undefined)
-    return false;
-  const liveFingerprint = sha256(JSON.stringify(existingValue));
-  return liveFingerprint !== recorded.fingerprint;
+function projectSkillsToDir(targetDir, skills, layout) {
+  const owned = loadOwnership2(targetDir);
+  const newPaths = new Set(skills.map((s) => layout === "dir" ? `${s.id}/SKILL.md` : `${s.id}.md`));
+  for (const ownedPath of owned.paths) {
+    if (!newPaths.has(ownedPath)) {
+      const fullPath = path7.join(targetDir, ownedPath);
+      try {
+        if (fs7.existsSync(fullPath)) {
+          fs7.rmSync(fullPath, { recursive: true, force: true });
+        }
+        if (layout === "dir") {
+          const dirPath = path7.join(targetDir, path7.dirname(ownedPath));
+          try {
+            const remaining = fs7.readdirSync(dirPath);
+            if (remaining.length === 0) {
+              fs7.rmSync(dirPath, { recursive: true, force: true });
+            }
+          } catch {}
+        }
+      } catch {
+        console.error(`[mcpx] Warning: could not remove stale skill projection: ${fullPath}`);
+      }
+    }
+  }
+  for (const skill of skills) {
+    const filePath = layout === "dir" ? path7.join(targetDir, skill.id, "SKILL.md") : path7.join(targetDir, `${skill.id}.md`);
+    ensureDir(path7.dirname(filePath));
+    fs7.writeFileSync(filePath, skill.content, "utf-8");
+  }
+  saveOwnership2(targetDir, { version: 1, paths: Array.from(newPaths) });
 }
 
 // src/adapters/claude.ts
 function normalizeProjectKey(p) {
   try {
-    return fs5.realpathSync(path5.resolve(p));
+    return fs8.realpathSync(path8.resolve(p));
   } catch {
-    return path5.resolve(p);
+    return path8.resolve(p);
   }
 }
 function syncProjectDisabledArray(project, managedNames, disabledForThisProject) {
@@ -833,22 +1493,22 @@ function syncProjectDisabledArray(project, managedNames, disabledForThisProject)
     delete project.disabledMcpServers;
   }
 }
-var stringMapSchema = z.record(z.string(), z.string());
-var claudeEntrySchema = z.object({
-  type: z.string().optional(),
-  url: z.string().min(1).optional(),
+var stringMapSchema = z2.record(z2.string(), z2.string());
+var claudeEntrySchema = z2.object({
+  type: z2.string().optional(),
+  url: z2.string().min(1).optional(),
   headers: stringMapSchema.optional(),
-  command: z.string().min(1).optional(),
-  args: z.array(z.string()).optional(),
+  command: z2.string().min(1).optional(),
+  args: z2.array(z2.string()).optional(),
   env: stringMapSchema.optional(),
-  cwd: z.string().min(1).optional(),
-  disabled: z.boolean().optional()
+  cwd: z2.string().min(1).optional(),
+  disabled: z2.boolean().optional()
 }).passthrough();
 
 class ClaudeAdapter {
   id = "claude";
   detectConfigPath() {
-    return path5.join(homeDir(), ".claude.json");
+    return path8.join(homeDir(), ".claude.json");
   }
   supportsHttp() {
     return true;
@@ -857,7 +1517,7 @@ class ClaudeAdapter {
     return syncPluginsToClient(this.id, plugins);
   }
   syncSkills(skills) {
-    projectSkillsToDir(path5.join(homeDir(), ".claude", "skills"), skills, "dir");
+    projectSkillsToDir(path8.join(homeDir(), ".claude", "skills"), skills, "dir");
   }
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
@@ -983,24 +1643,29 @@ class ClaudeAdapter {
 }
 
 // src/adapters/claude-desktop.ts
-import { execFileSync } from "node:child_process";
-import path6 from "node:path";
-import { z as z2 } from "zod";
-var stringMapSchema2 = z2.record(z2.string(), z2.string());
-var claudeDesktopEntrySchema = z2.object({
-  type: z2.string().optional(),
-  url: z2.string().min(1).optional(),
+import { execFileSync as execFileSync3 } from "node:child_process";
+import path9 from "node:path";
+import { z as z3 } 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(),
   headers: stringMapSchema2.optional(),
-  command: z2.string().min(1).optional(),
-  args: z2.array(z2.string()).optional(),
+  command: z3.string().min(1).optional(),
+  args: z3.array(z3.string()).optional(),
   env: stringMapSchema2.optional(),
-  cwd: z2.string().min(1).optional(),
-  disabled: z2.boolean().optional()
+  cwd: z3.string().min(1).optional(),
+  disabled: z3.boolean().optional()
 }).passthrough();
 function buildProxyEntry(entry) {
   const upstreamName = entry.name.replace(/ \(mcpx\)$/, "");
   try {
-    const mcpxPath = execFileSync("which", ["mcpx"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const mcpxPath = execFileSync3("which", ["mcpx"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     if (mcpxPath)
       return { command: mcpxPath, args: ["proxy", upstreamName] };
   } catch {}
@@ -1011,12 +1676,12 @@ class ClaudeDesktopAdapter {
   id = "claude-desktop";
   detectConfigPath() {
     if (process.platform === "linux") {
-      return path6.join(homeDir(), ".config", "Claude", "claude_desktop_config.json");
+      return path9.join(homeDir(), ".config", "Claude", "claude_desktop_config.json");
     }
     if (process.platform === "win32") {
-      return path6.join(process.env.APPDATA ?? "", "Claude", "claude_desktop_config.json");
+      return path9.join(process.env.APPDATA ?? "", "Claude", "claude_desktop_config.json");
     }
-    return path6.join(homeDir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return path9.join(homeDir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   supportsHttp() {
     return true;
@@ -1029,7 +1694,7 @@ class ClaudeDesktopAdapter {
     if (!configPath) {
       return;
     }
-    projectSkillsToDir(path6.join(path6.dirname(configPath), "skills"), skills, "dir");
+    projectSkillsToDir(path9.join(path9.dirname(configPath), "skills"), skills, "dir");
   }
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
@@ -1125,31 +1790,31 @@ class ClaudeDesktopAdapter {
 }
 
 // src/adapters/codex.ts
-import path7 from "node:path";
-import fs6 from "node:fs";
+import path10 from "node:path";
+import fs9 from "node:fs";
 import { parse, stringify } from "@iarna/toml";
-import { z as z3 } from "zod";
-var stringMapSchema3 = z3.preprocess((value) => {
+import { z as z4 } from "zod";
+var stringMapSchema3 = z4.preprocess((value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return value;
   }
   return Object.fromEntries(Object.entries(value));
-}, z3.record(z3.string(), z3.string()));
-var codexEntrySchema = z3.object({
-  enabled: z3.boolean().optional(),
-  url: z3.string().min(1).optional(),
+}, z4.record(z4.string(), z4.string()));
+var codexEntrySchema = z4.object({
+  enabled: z4.boolean().optional(),
+  url: z4.string().min(1).optional(),
   headers: stringMapSchema3.optional(),
   http_headers: stringMapSchema3.optional(),
-  command: z3.string().min(1).optional(),
-  args: z3.array(z3.string()).optional(),
+  command: z4.string().min(1).optional(),
+  args: z4.array(z4.string()).optional(),
   env: stringMapSchema3.optional(),
-  cwd: z3.string().min(1).optional()
+  cwd: z4.string().min(1).optional()
 }).passthrough();
 
 class CodexAdapter {
   id = "codex";
   detectConfigPath() {
-    return path7.join(homeDir(), ".codex", "config.toml");
+    return path10.join(homeDir(), ".codex", "config.toml");
   }
   supportsHttp() {
     return true;
@@ -1158,15 +1823,15 @@ class CodexAdapter {
     return syncPluginsToClient(this.id, plugins);
   }
   syncSkills(skills) {
-    projectSkillsToDir(path7.join(homeDir(), ".codex", "skills"), skills, "dir");
+    projectSkillsToDir(path10.join(homeDir(), ".codex", "skills"), skills, "dir");
   }
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
     const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs6.existsSync(configPath)) {
+    if (!configPath || !fs9.existsSync(configPath)) {
       return result;
     }
-    const existing = fs6.readFileSync(configPath, "utf8");
+    const existing = fs9.readFileSync(configPath, "utf8");
     const doc = existing.trim().length > 0 ? parse(existing) : {};
     const mcpServers = doc.mcp_servers ?? {};
     for (const [name, rawEntry] of Object.entries(mcpServers)) {
@@ -1221,7 +1886,7 @@ class CodexAdapter {
       return errorResult(this.id, undefined, "Unable to resolve Codex config.toml path.");
     }
     try {
-      const existing = fs6.existsSync(configPath) ? fs6.readFileSync(configPath, "utf8") : "";
+      const existing = fs9.existsSync(configPath) ? fs9.readFileSync(configPath, "utf8") : "";
       const doc = existing.trim().length > 0 ? parse(existing) : {};
       const mcpServers = doc.mcp_servers ?? {};
       removeSourceEntries(mcpServers, options.sourceEntriesToRemove);
@@ -1244,10 +1909,10 @@ class CodexAdapter {
         mcpServers[name] = entry;
       }
       doc.mcp_servers = mcpServers;
-      fs6.mkdirSync(path7.dirname(configPath), { recursive: true });
+      fs9.mkdirSync(path10.dirname(configPath), { recursive: true });
       const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
-      fs6.writeFileSync(tmpPath, stringify(doc), { mode: 384 });
-      fs6.renameSync(tmpPath, configPath);
+      fs9.writeFileSync(tmpPath, stringify(doc), { mode: 384 });
+      fs9.renameSync(tmpPath, configPath);
       setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(Object.entries(serverEntries).map(([name, entry]) => [name, JSON.stringify(entry)])));
       return { ...okResult(this.id, configPath), driftedEntries: driftedNames.length > 0 ? driftedNames : undefined };
     } catch (error) {
@@ -1257,24 +1922,24 @@ class CodexAdapter {
 }
 
 // src/adapters/cursor.ts
-import path8 from "node:path";
-import { z as z4 } from "zod";
-var stringMapSchema4 = z4.record(z4.string(), z4.string());
-var cursorEntrySchema = z4.object({
-  type: z4.string().optional(),
-  url: z4.string().min(1).optional(),
+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(),
   headers: stringMapSchema4.optional(),
-  command: z4.string().min(1).optional(),
-  args: z4.array(z4.string()).optional(),
+  command: z5.string().min(1).optional(),
+  args: z5.array(z5.string()).optional(),
   env: stringMapSchema4.optional(),
-  cwd: z4.string().min(1).optional(),
-  disabled: z4.boolean().optional()
+  cwd: z5.string().min(1).optional(),
+  disabled: z5.boolean().optional()
 }).passthrough();
 
 class CursorAdapter {
   id = "cursor";
   detectConfigPath() {
-    return path8.join(homeDir(), ".cursor", "mcp.json");
+    return path11.join(homeDir(), ".cursor", "mcp.json");
   }
   supportsHttp() {
     return true;
@@ -1283,7 +1948,7 @@ class CursorAdapter {
     return syncPluginsToClient(this.id, plugins);
   }
   syncSkills(skills) {
-    projectSkillsToDir(path8.join(homeDir(), ".cursor", "skills"), skills, "dir");
+    projectSkillsToDir(path11.join(homeDir(), ".cursor", "skills"), skills, "dir");
   }
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
@@ -1387,41 +2052,41 @@ class CursorAdapter {
 }
 
 // src/adapters/cline.ts
-import path9 from "node:path";
-import fs7 from "node:fs";
-import { z as z5 } from "zod";
+import path12 from "node:path";
+import fs10 from "node:fs";
+import { z as z6 } from "zod";
 var HTTP_TRANSPORT_TYPES = new Set(["http", "sse", "streamableHttp"]);
-var stringMapSchema5 = z5.record(z5.string(), z5.string());
-var clineEntrySchema = z5.object({
-  type: z5.string().optional(),
-  transportType: z5.string().optional(),
-  url: z5.string().min(1).optional(),
+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(),
   headers: stringMapSchema5.optional(),
-  command: z5.string().min(1).optional(),
-  args: z5.array(z5.string()).optional(),
+  command: z6.string().min(1).optional(),
+  args: z6.array(z6.string()).optional(),
   env: stringMapSchema5.optional(),
-  cwd: z5.string().min(1).optional(),
-  disabled: z5.boolean().optional()
+  cwd: z6.string().min(1).optional(),
+  disabled: z6.boolean().optional()
 }).passthrough();
 function getCandidatePaths() {
   if (process.platform === "linux") {
     return [
-      path9.join(homeDir(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-      path9.join(homeDir(), ".config", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-      path9.join(homeDir(), ".cline", "settings", "cline_mcp_settings.json")
+      path12.join(homeDir(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path12.join(homeDir(), ".config", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path12.join(homeDir(), ".cline", "settings", "cline_mcp_settings.json")
     ];
   }
   if (process.platform === "win32") {
     return [
-      path9.join(process.env.APPDATA ?? "", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-      path9.join(process.env.APPDATA ?? "", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-      path9.join(homeDir(), ".cline", "settings", "cline_mcp_settings.json")
+      path12.join(process.env.APPDATA ?? "", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path12.join(process.env.APPDATA ?? "", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path12.join(homeDir(), ".cline", "settings", "cline_mcp_settings.json")
     ];
   }
   return [
-    path9.join(homeDir(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-    path9.join(homeDir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-    path9.join(homeDir(), ".cline", "settings", "cline_mcp_settings.json")
+    path12.join(homeDir(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+    path12.join(homeDir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+    path12.join(homeDir(), ".cline", "settings", "cline_mcp_settings.json")
   ];
 }
 
@@ -1430,7 +2095,7 @@ class ClineAdapter {
   detectConfigPath() {
     const candidates = getCandidatePaths();
     for (const candidate of candidates) {
-      if (fs7.existsSync(candidate)) {
+      if (fs10.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -1443,12 +2108,12 @@ class ClineAdapter {
     return syncPluginsToClient(this.id, plugins);
   }
   syncSkills(skills) {
-    projectSkillsToDir(path9.join(homeDir(), ".config", "cline", "skills"), skills, "dir");
+    projectSkillsToDir(path12.join(homeDir(), ".config", "cline", "skills"), skills, "dir");
   }
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
     const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs7.existsSync(configPath)) {
+    if (!configPath || !fs10.existsSync(configPath)) {
       return result;
     }
     const raw = readJsonFile(configPath, {});
@@ -1507,7 +2172,7 @@ class ClineAdapter {
     if (!configPath) {
       return errorResult(this.id, undefined, "Unable to resolve Cline MCP config path.");
     }
-    if (!fs7.existsSync(configPath)) {
+    if (!fs10.existsSync(configPath)) {
       return okResult(this.id, configPath, "Cline config not found; skipping sync.");
     }
     try {
@@ -1549,24 +2214,24 @@ class ClineAdapter {
 }
 
 // src/adapters/kiro.ts
-import path10 from "node:path";
-import { z as z6 } from "zod";
-var stringMapSchema6 = z6.record(z6.string(), z6.string());
-var kiroEntrySchema = z6.object({
-  type: z6.string().optional(),
-  url: z6.string().min(1).optional(),
+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(),
   headers: stringMapSchema6.optional(),
-  command: z6.string().min(1).optional(),
-  args: z6.array(z6.string()).optional(),
+  command: z7.string().min(1).optional(),
+  args: z7.array(z7.string()).optional(),
   env: stringMapSchema6.optional(),
-  cwd: z6.string().min(1).optional(),
-  disabled: z6.boolean().optional()
+  cwd: z7.string().min(1).optional(),
+  disabled: z7.boolean().optional()
 }).passthrough();
 
 class KiroAdapter {
   id = "kiro";
   detectConfigPath() {
-    return path10.join(homeDir(), ".kiro", "settings", "mcp.json");
+    return path13.join(homeDir(), ".kiro", "settings", "mcp.json");
   }
   supportsHttp() {
     return true;
@@ -1671,30 +2336,30 @@ class KiroAdapter {
     }
   }
   syncSkills(skills) {
-    projectSkillsToDir(path10.join(homeDir(), ".kiro", "skills"), skills, "flat");
+    projectSkillsToDir(path13.join(homeDir(), ".kiro", "skills"), skills, "flat");
   }
 }
 
 // src/adapters/opencode.ts
-import path11 from "node:path";
-import { z as z7 } from "zod";
-var stringMapSchema7 = z7.record(z7.string(), z7.string());
-var openCodeEntrySchema = z7.object({
-  type: z7.string().optional(),
-  url: z7.string().min(1).optional(),
+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(),
   headers: stringMapSchema7.optional(),
-  command: z7.union([z7.string().min(1), z7.array(z7.string())]).optional(),
-  args: z7.array(z7.string()).optional(),
+  command: z8.union([z8.string().min(1), z8.array(z8.string())]).optional(),
+  args: z8.array(z8.string()).optional(),
   env: stringMapSchema7.optional(),
   environment: stringMapSchema7.optional(),
-  cwd: z7.string().min(1).optional(),
-  enabled: z7.boolean().optional()
+  cwd: z8.string().min(1).optional(),
+  enabled: z8.boolean().optional()
 }).passthrough();
 
 class OpenCodeAdapter {
   id = "opencode";
   detectConfigPath() {
-    return path11.join(homeDir(), ".config", "opencode", "opencode.json");
+    return path14.join(homeDir(), ".config", "opencode", "opencode.json");
   }
   supportsHttp() {
     return true;
@@ -1707,7 +2372,7 @@ class OpenCodeAdapter {
     if (!configPath) {
       return;
     }
-    projectSkillsToDir(path11.join(path11.dirname(configPath), "skills"), skills, "dir");
+    projectSkillsToDir(path14.join(path14.dirname(configPath), "skills"), skills, "dir");
   }
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
@@ -1814,30 +2479,30 @@ class OpenCodeAdapter {
 }
 
 // src/adapters/vscode.ts
-import path12 from "node:path";
-import { z as z8 } from "zod";
-var stringMapSchema8 = z8.record(z8.string(), z8.string());
-var vscodeEntrySchema = z8.object({
-  type: z8.string().optional(),
-  url: z8.string().min(1).optional(),
+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(),
   headers: stringMapSchema8.optional(),
-  command: z8.string().min(1).optional(),
-  args: z8.array(z8.string()).optional(),
+  command: z9.string().min(1).optional(),
+  args: z9.array(z9.string()).optional(),
   env: stringMapSchema8.optional(),
-  cwd: z8.string().min(1).optional(),
-  disabled: z8.boolean().optional()
+  cwd: z9.string().min(1).optional(),
+  disabled: z9.boolean().optional()
 }).passthrough();
 
 class VsCodeAdapter {
   id = "vscode";
   detectConfigPath() {
     if (process.platform === "linux") {
-      return path12.join(homeDir(), ".config", "Code", "User", "mcp.json");
+      return path15.join(homeDir(), ".config", "Code", "User", "mcp.json");
     }
     if (process.platform === "win32") {
-      return path12.join(process.env.APPDATA ?? "", "Code", "User", "mcp.json");
+      return path15.join(process.env.APPDATA ?? "", "Code", "User", "mcp.json");
     }
-    return path12.join(homeDir(), "Library", "Application Support", "Code", "User", "mcp.json");
+    return path15.join(homeDir(), "Library", "Application Support", "Code", "User", "mcp.json");
   }
   supportsHttp() {
     return true;
@@ -1846,7 +2511,7 @@ class VsCodeAdapter {
     return syncPluginsToClient(this.id, plugins);
   }
   syncSkills(skills) {
-    projectSkillsToDir(path12.join(homeDir(), ".copilot", "skills"), skills, "dir");
+    projectSkillsToDir(path15.join(homeDir(), ".copilot", "skills"), skills, "dir");
   }
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
@@ -1950,24 +2615,24 @@ class VsCodeAdapter {
 }
 
 // src/adapters/qwen.ts
-import path13 from "node:path";
-import { z as z9 } from "zod";
-var stringMapSchema9 = z9.record(z9.string(), z9.string());
-var qwenEntrySchema = z9.object({
-  httpUrl: z9.string().min(1).optional(),
-  url: z9.string().min(1).optional(),
+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(),
   headers: stringMapSchema9.optional(),
-  command: z9.string().min(1).optional(),
-  args: z9.array(z9.string()).optional(),
+  command: z10.string().min(1).optional(),
+  args: z10.array(z10.string()).optional(),
   env: stringMapSchema9.optional(),
-  cwd: z9.string().min(1).optional(),
-  disabled: z9.boolean().optional()
+  cwd: z10.string().min(1).optional(),
+  disabled: z10.boolean().optional()
 }).passthrough();
 
 class QwenAdapter {
   id = "qwen";
   detectConfigPath() {
-    return path13.join(homeDir(), ".qwen", "settings.json");
+    return path16.join(homeDir(), ".qwen", "settings.json");
   }
   supportsHttp() {
     return true;
@@ -2085,31 +2750,31 @@ class QwenAdapter {
     }
   }
   syncSkills(skills) {
-    projectSkillsToDir(path13.join(homeDir(), ".qwen", "skills"), skills, "flat");
+    projectSkillsToDir(path16.join(homeDir(), ".qwen", "skills"), skills, "flat");
   }
 }
 
 // src/adapters/openclaw.ts
-import fs8 from "node:fs";
-import path14 from "node:path";
-import { z as z10 } from "zod";
-var stringMapSchema10 = z10.record(z10.string(), z10.string());
-var openclawEntrySchema = z10.object({
-  url: z10.string().min(1).optional(),
-  transport: z10.string().optional(),
+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(),
   headers: stringMapSchema10.optional(),
-  command: z10.string().min(1).optional(),
-  args: z10.array(z10.string()).optional(),
+  command: z11.string().min(1).optional(),
+  args: z11.array(z11.string()).optional(),
   env: stringMapSchema10.optional(),
-  cwd: z10.string().min(1).optional(),
-  workingDirectory: z10.string().min(1).optional(),
-  auth: z10.unknown().optional()
+  cwd: z11.string().min(1).optional(),
+  workingDirectory: z11.string().min(1).optional(),
+  auth: z11.unknown().optional()
 }).passthrough();
 
 class OpenClawAdapter {
   id = "openclaw";
   detectConfigPath() {
-    return process.env.OPENCLAW_CONFIG_PATH ?? path14.join(homeDir(), ".openclaw", "openclaw.json");
+    return process.env.OPENCLAW_CONFIG_PATH ?? path17.join(homeDir(), ".openclaw", "openclaw.json");
   }
   supportsHttp() {
     return true;
@@ -2118,7 +2783,7 @@ class OpenClawAdapter {
     return syncPluginsToClient(this.id, plugins);
   }
   syncSkills(skills) {
-    projectSkillsToDir(path14.join(homeDir(), ".openclaw", "skills"), skills, "dir");
+    projectSkillsToDir(path17.join(homeDir(), ".openclaw", "skills"), skills, "dir");
   }
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
@@ -2128,7 +2793,7 @@ class OpenClawAdapter {
     }
     let raw;
     try {
-      raw = JSON.parse(fs8.readFileSync(configPath, "utf8"));
+      raw = JSON.parse(fs11.readFileSync(configPath, "utf8"));
     } catch {
       return result;
     }
@@ -2195,9 +2860,9 @@ class OpenClawAdapter {
     }
     try {
       let raw;
-      if (fs8.existsSync(configPath)) {
+      if (fs11.existsSync(configPath)) {
         try {
-          raw = JSON.parse(fs8.readFileSync(configPath, "utf8"));
+          raw = JSON.parse(fs11.readFileSync(configPath, "utf8"));
         } catch {
           return errorResult(this.id, configPath, "OpenClaw config contains invalid JSON (possibly JSON5). Cannot safely write.");
         }
@@ -2240,27 +2905,27 @@ class OpenClawAdapter {
 }
 
 // src/adapters/hermes.ts
-import fs9 from "node:fs";
-import path15 from "node:path";
+import fs12 from "node:fs";
+import path18 from "node:path";
 import YAML from "yaml";
-import { z as z11 } from "zod";
-var stringMapSchema11 = z11.record(z11.string(), z11.string());
-var hermesEntrySchema = z11.object({
-  url: z11.string().min(1).optional(),
+import { z as z12 } from "zod";
+var stringMapSchema11 = z12.record(z12.string(), z12.string());
+var hermesEntrySchema = z12.object({
+  url: z12.string().min(1).optional(),
   headers: stringMapSchema11.optional(),
-  command: z11.string().min(1).optional(),
-  args: z11.array(z11.string()).optional(),
+  command: z12.string().min(1).optional(),
+  args: z12.array(z12.string()).optional(),
   env: stringMapSchema11.optional(),
-  auth: z11.unknown().optional(),
-  enabled: z11.boolean().optional(),
-  timeout: z11.number().optional(),
-  tools: z11.array(z11.string()).optional()
+  auth: z12.unknown().optional(),
+  enabled: z12.boolean().optional(),
+  timeout: z12.number().optional(),
+  tools: z12.array(z12.string()).optional()
 }).passthrough();
 
 class HermesAdapter {
   id = "hermes";
   detectConfigPath() {
-    return path15.join(homeDir(), ".hermes", "config.yaml");
+    return path18.join(homeDir(), ".hermes", "config.yaml");
   }
   supportsHttp() {
     return true;
@@ -2269,15 +2934,15 @@ class HermesAdapter {
     return syncPluginsToClient(this.id, plugins);
   }
   syncSkills(skills) {
-    projectSkillsToDir(path15.join(homeDir(), ".hermes", "skills"), skills, "dir");
+    projectSkillsToDir(path18.join(homeDir(), ".hermes", "skills"), skills, "dir");
   }
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
     const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs9.existsSync(configPath)) {
+    if (!configPath || !fs12.existsSync(configPath)) {
       return result;
     }
-    const existing = fs9.readFileSync(configPath, "utf8");
+    const existing = fs12.readFileSync(configPath, "utf8");
     const doc = YAML.parse(existing) ?? {};
     const mcpServers = doc.mcp_servers ?? {};
     for (const [name, rawEntry] of Object.entries(mcpServers)) {
@@ -2335,7 +3000,7 @@ class HermesAdapter {
       return errorResult(this.id, undefined, "Unable to resolve Hermes config.yaml path.");
     }
     try {
-      const existing = fs9.existsSync(configPath) ? fs9.readFileSync(configPath, "utf8") : "";
+      const existing = fs12.existsSync(configPath) ? fs12.readFileSync(configPath, "utf8") : "";
       const doc = existing.trim().length > 0 ? YAML.parse(existing) ?? {} : {};
       const mcpServers = doc.mcp_servers ?? {};
       removeSourceEntries(mcpServers, options.sourceEntriesToRemove);
@@ -2356,10 +3021,10 @@ class HermesAdapter {
         mcpServers[name] = entry;
       }
       doc.mcp_servers = mcpServers;
-      fs9.mkdirSync(path15.dirname(configPath), { recursive: true });
+      fs12.mkdirSync(path18.dirname(configPath), { recursive: true });
       const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
-      fs9.writeFileSync(tmpPath, YAML.stringify(doc), { mode: 384 });
-      fs9.renameSync(tmpPath, configPath);
+      fs12.writeFileSync(tmpPath, YAML.stringify(doc), { mode: 384 });
+      fs12.renameSync(tmpPath, configPath);
       setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(Object.entries(serverEntries).map(([name, entry]) => [name, JSON.stringify(entry)])));
       return okResult(this.id, configPath);
     } catch (error) {
@@ -2406,29 +3071,71 @@ function saveManagedIndex(index, filePath = getManagedIndexPath()) {
   writeJsonAtomic(filePath, index);
 }
 
+// src/core/skills.ts
+import fs13 from "node:fs";
+import path19 from "node:path";
+function listSkills() {
+  const skillsDir = getSkillsDir();
+  if (!fs13.existsSync(skillsDir)) {
+    return [];
+  }
+  const files = fs13.readdirSync(skillsDir);
+  const skills = [];
+  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 });
+    }
+  }
+  return skills;
+}
+function getSkill(id) {
+  const skillsDir = getSkillsDir();
+  const filePath = path19.join(skillsDir, `${id}.md`);
+  if (!fs13.existsSync(filePath)) {
+    return null;
+  }
+  const content = fs13.readFileSync(filePath, "utf-8");
+  return { id, content };
+}
+function saveSkill(id, content) {
+  const skillsDir = getSkillsDir();
+  ensureDir(skillsDir);
+  const filePath = path19.join(skillsDir, `${id}.md`);
+  fs13.writeFileSync(filePath, content, "utf-8");
+}
+function deleteSkill(id) {
+  const skillsDir = getSkillsDir();
+  const filePath = path19.join(skillsDir, `${id}.md`);
+  if (fs13.existsSync(filePath)) {
+    fs13.unlinkSync(filePath);
+  }
+}
+
 // src/core/managed-index-lock.ts
-import fs10 from "node:fs";
-import path16 from "node:path";
+import fs14 from "node:fs";
+import path20 from "node:path";
 function isStale(lockPath, maxAgeMs = 5000) {
   try {
-    const stat = fs10.statSync(lockPath);
+    const stat = fs14.statSync(lockPath);
     return Date.now() - stat.mtimeMs > maxAgeMs;
   } catch {
     return true;
   }
 }
 function withManagedIndexLock(lockPath, fn) {
-  fs10.mkdirSync(path16.dirname(lockPath), { recursive: true });
+  fs14.mkdirSync(path20.dirname(lockPath), { recursive: true });
   const deadline = Date.now() + 5000;
   while (true) {
     try {
-      fs10.writeFileSync(lockPath, `${process.pid}
+      fs14.writeFileSync(lockPath, `${process.pid}
 `, { flag: "wx" });
       break;
     } catch {
       if (isStale(lockPath)) {
         try {
-          fs10.unlinkSync(lockPath);
+          fs14.unlinkSync(lockPath);
         } catch {}
         continue;
       }
@@ -2441,7 +3148,7 @@ function withManagedIndexLock(lockPath, fn) {
     return fn();
   } finally {
     try {
-      fs10.unlinkSync(lockPath);
+      fs14.unlinkSync(lockPath);
     } catch {}
   }
 }
@@ -2713,4 +3420,421 @@ function persistSyncState(summary, config) {
   }
 }
 
-export { mutateConfig, mutateProjectConfig, mutateActiveConfig, listSkills, getSkill, saveSkill, deleteSkill, prunePluginProjections, pruneAllPluginProjections, syncPluginsToClient, APP_VERSION, getAdapters, loadManagedIndex, getGatewayUrl, syncAllClients, persistSyncState };
+// src/core/plugin-manager.ts
+class PluginManager {
+  configPath;
+  cache;
+  dataManager;
+  lifecycle;
+  secrets;
+  constructor(configPath) {
+    this.configPath = configPath || getConfigPath();
+    this.cache = new PluginCache;
+    this.dataManager = new PluginDataManager;
+    this.lifecycle = new PluginLifecycle;
+    this.secrets = new SecretsManager;
+  }
+  async inspectSource(sourceStr) {
+    const parsed = parseSource(sourceStr);
+    return this.inspectResolvedSource(parsed, sourceStr);
+  }
+  async inspectResolvedSource(parsed, sourceLabel = parsed.original) {
+    const sha = parsed.resolvedSha || await this.cache.resolveSha(parsed);
+    parsed.resolvedSha = sha;
+    const cached = await this.cache.fetch(parsed, "");
+    let pluginRoot = cached.root;
+    if (!hasManifest(pluginRoot)) {
+      const entries = fs15.readdirSync(pluginRoot, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const candidate = path21.join(pluginRoot, entry.name);
+          if (hasManifest(candidate)) {
+            pluginRoot = candidate;
+            break;
+          }
+        }
+      }
+    }
+    const manifest = readManifest(pluginRoot);
+    const components = discoverComponents(pluginRoot);
+    return { manifest, components, root: pluginRoot, source: sourceLabel, sha: cached.sha };
+  }
+  async installPlugin(sourceStr, options) {
+    return this.installResolvedPlugin(parseSource(sourceStr), options, sourceStr);
+  }
+  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 pluginId = `${pluginName}@${info.sha.slice(0, 8)}`;
+    const dataDir = path21.join(getPluginDataRoot(), pluginId);
+    ensureDir(dataDir);
+    const enabled = options?.enabled ?? true;
+    const discovered = info.components;
+    const serverNames = discovered.mcpServers.map((s) => `${pluginName}__${s.id}`);
+    const plugin = {
+      id: pluginId,
+      name: pluginName,
+      source: sourceLabel,
+      version: info.manifest?.version || "0.0.0",
+      ref: source.ref || "latest",
+      resolvedSha: info.sha,
+      installedAt: new Date().toISOString(),
+      root: info.root,
+      dataDir,
+      components: {
+        mcpServers: options?.components?.mcpServers ?? discovered.mcpServers.length > 0,
+        skills: options?.components?.skills ?? discovered.skills.length > 0,
+        hooks: options?.components?.hooks ?? discovered.hooks.length > 0,
+        agents: options?.components?.agents ?? discovered.agents.length > 0,
+        commands: options?.components?.commands ?? discovered.commands.length > 0
+      },
+      discovered,
+      enabled,
+      status: "healthy",
+      serverNames,
+      projectedClients: [],
+      approvals: options?.approvals || {},
+      marketplace: options?.marketplace
+    };
+    await mutateConfig((config) => {
+      if (!config.plugins)
+        config.plugins = {};
+      if (config.plugins[pluginId]) {
+        throw new Error(`Plugin ${pluginId} is already installed`);
+      }
+      for (const existing of Object.values(config.plugins)) {
+        for (const sn of serverNames) {
+          if (existing.serverNames.includes(sn)) {
+            throw new Error(`Server name collision: "${sn}" is already claimed by plugin "${existing.name}". Use --name to specify a different plugin name.`);
+          }
+        }
+      }
+      for (const sn of serverNames) {
+        if (config.servers?.[sn]) {
+          throw new Error(`Server name collision: "${sn}" is already registered as a server. Remove that server or use --name to choose a different plugin name.`);
+        }
+      }
+      config.plugins[pluginId] = plugin;
+      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 } : {
+          transport: "stdio",
+          command: "npx",
+          args: ["-y", "@kwonye/mcpx@latest", "plugin-host", pluginId, mcp.id],
+          enabled: enabled && approved
+        };
+      }
+    }, this.configPath);
+    this.lifecycle.initData(pluginId);
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    await mutateConfig((freshConfig) => {
+      persistSyncState(summary, freshConfig);
+    }, this.configPath);
+    return plugin;
+  }
+  async updatePlugin(pluginId) {
+    const current = loadConfig(this.configPath).plugins?.[pluginId];
+    if (!current)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const info = await this.inspectSource(current.source);
+    return this.applyPluginUpdate(pluginId, info, undefined, true);
+  }
+  async updateResolvedPlugin(pluginId, source, sourceFingerprint, sync = true) {
+    const info = await this.inspectResolvedSource(source);
+    return this.applyPluginUpdate(pluginId, info, sourceFingerprint, sync);
+  }
+  async applyPluginUpdate(pluginId, info, sourceFingerprint, sync = true) {
+    const currentSnapshot = loadConfig(this.configPath).plugins?.[pluginId];
+    if (!currentSnapshot)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const pluginName = info.manifest?.name || currentSnapshot.name;
+    let updatedPlugin;
+    await mutateConfig((config) => {
+      if (!config.plugins)
+        throw new Error(`Plugin ${pluginId} not found`);
+      const current = config.plugins[pluginId];
+      if (!current)
+        throw new Error(`Plugin ${pluginId} not found`);
+      for (const oldName of current.serverNames) {
+        delete config.servers[oldName];
+      }
+      current.version = info.manifest?.version || current.version;
+      current.resolvedSha = info.sha;
+      current.root = info.root;
+      current.discovered = info.components;
+      current.serverNames = info.components.mcpServers.map((s) => `${pluginName}__${s.id}`);
+      const approved = 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 } : {
+          transport: "stdio",
+          command: "npx",
+          args: ["-y", "@kwonye/mcpx@latest", "plugin-host", pluginId, mcp.id],
+          enabled: current.enabled && approved
+        };
+      }
+      current.approvals = {};
+      if (sourceFingerprint && current.marketplace)
+        current.marketplace.sourceFingerprint = sourceFingerprint;
+      delete current.updateError;
+      config.plugins[pluginId] = current;
+      updatedPlugin = current;
+    }, this.configPath);
+    if (sync) {
+      const syncConfig = loadConfig(this.configPath);
+      const summary = syncAllClients(syncConfig, this.secrets);
+      await mutateConfig((freshConfig) => {
+        persistSyncState(summary, freshConfig);
+      }, this.configPath);
+    }
+    return updatedPlugin;
+  }
+  async uninstallPlugin(pluginId, keepData = false) {
+    await mutateConfig((config) => {
+      if (!config.plugins)
+        throw new Error(`Plugin ${pluginId} not found`);
+      const plugin = config.plugins[pluginId];
+      if (!plugin)
+        throw new Error(`Plugin ${pluginId} not found`);
+      for (const name of plugin.serverNames) {
+        delete config.servers[name];
+      }
+      delete config.plugins[pluginId];
+    }, this.configPath);
+    if (!keepData) {
+      await this.lifecycle.removeData(pluginId);
+    }
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    await mutateConfig((freshConfig) => {
+      persistSyncState(summary, freshConfig);
+    }, this.configPath);
+  }
+  async enablePlugin(pluginId) {
+    await mutateConfig((config) => {
+      if (!config.plugins)
+        throw new Error(`Plugin ${pluginId} not found`);
+      const plugin = config.plugins[pluginId];
+      if (!plugin)
+        throw new Error(`Plugin ${pluginId} not found`);
+      plugin.enabled = true;
+    }, this.configPath);
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    await mutateConfig((freshConfig) => {
+      persistSyncState(summary, freshConfig);
+    }, this.configPath);
+  }
+  async disablePlugin(pluginId) {
+    await mutateConfig((config) => {
+      if (!config.plugins)
+        throw new Error(`Plugin ${pluginId} not found`);
+      const plugin = config.plugins[pluginId];
+      if (!plugin)
+        throw new Error(`Plugin ${pluginId} not found`);
+      plugin.enabled = false;
+    }, this.configPath);
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    await mutateConfig((freshConfig) => {
+      persistSyncState(summary, freshConfig);
+    }, this.configPath);
+  }
+  async approveComponent(pluginId, component) {
+    await mutateConfig((config) => {
+      if (!config.plugins)
+        throw new Error(`Plugin ${pluginId} not found`);
+      const plugin = config.plugins[pluginId];
+      if (!plugin)
+        throw new Error(`Plugin ${pluginId} not found`);
+      if (!plugin.approvals)
+        plugin.approvals = {};
+      plugin.approvals[component] = true;
+      if (component === "mcpServers") {
+        for (const name of plugin.serverNames) {
+          if (config.servers[name]) {
+            config.servers[name].enabled = plugin.enabled;
+          }
+        }
+      }
+    }, this.configPath);
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    await mutateConfig((freshConfig) => {
+      persistSyncState(summary, freshConfig);
+    }, this.configPath);
+  }
+  async getPluginStatus(pluginId) {
+    const config = loadConfig(this.configPath);
+    return config.plugins?.[pluginId] || null;
+  }
+  async listPlugins() {
+    const config = loadConfig(this.configPath);
+    return Object.values(config.plugins || {});
+  }
+  async preparePlugin(pluginId) {
+    const config = loadConfig(this.configPath);
+    if (!config.plugins)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const plugin = config.plugins[pluginId];
+    if (!plugin)
+      throw new Error(`Plugin ${pluginId} not found`);
+    await this.lifecycle.prepareDependencies(pluginId, plugin.root);
+  }
+}
+async function inspectPlugin(source) {
+  const manager = new PluginManager;
+  return manager.inspectSource(source);
+}
+async function installPlugin(source, options) {
+  const manager = new PluginManager;
+  return manager.installPlugin(source, options);
+}
+async function updatePlugin(nameOrId) {
+  const manager = new PluginManager;
+  const config = loadConfig(manager["configPath"]);
+  const id = resolvePluginId(config, nameOrId);
+  if (config.plugins?.[id]?.marketplace) {
+    const { updateMarketplaceInstalledPlugin } = await import("./marketplace-pwabb3ea.js");
+    return updateMarketplaceInstalledPlugin(id);
+  }
+  return manager.updatePlugin(id);
+}
+async function uninstallPlugin(nameOrId, keepData) {
+  const manager = new PluginManager;
+  const config = loadConfig(manager["configPath"]);
+  const id = resolvePluginId(config, nameOrId);
+  await manager.uninstallPlugin(id, keepData);
+}
+async function enablePlugin(nameOrId) {
+  const manager = new PluginManager;
+  const config = loadConfig(manager["configPath"]);
+  const id = resolvePluginId(config, nameOrId);
+  await manager.enablePlugin(id);
+}
+async function disablePlugin(nameOrId) {
+  const manager = new PluginManager;
+  const config = loadConfig(manager["configPath"]);
+  const id = resolvePluginId(config, nameOrId);
+  await manager.disablePlugin(id);
+}
+async function setPluginProjectOverride(nameOrId, projectPath, override) {
+  await mutateConfig((config) => {
+    const id = resolvePluginId(config, nameOrId);
+    const plugin = config.plugins?.[id];
+    if (!plugin)
+      throw new Error(`Plugin ${id} not found`);
+    if (!config.projects?.[projectPath]) {
+      throw new Error(`Project "${projectPath}" is not registered. Run "mcpx project init" there first.`);
+    }
+    if (!plugin.projectOverrides)
+      plugin.projectOverrides = {};
+    plugin.projectOverrides[projectPath] = { ...plugin.projectOverrides[projectPath], ...override };
+  });
+  const secrets = new SecretsManager;
+  const syncConfig = loadConfig();
+  const summary = syncAllClients(syncConfig, secrets);
+  await mutateConfig((freshConfig) => {
+    persistSyncState(summary, freshConfig);
+  });
+}
+async function resetPluginProjectOverride(nameOrId, projectPath) {
+  await mutateConfig((config) => {
+    const id = resolvePluginId(config, nameOrId);
+    const plugin = config.plugins?.[id];
+    if (!plugin)
+      throw new Error(`Plugin ${id} not found`);
+    if (!config.projects?.[projectPath]) {
+      throw new Error(`Project "${projectPath}" is not registered. Run "mcpx project init" there first.`);
+    }
+    if (!plugin.projectOverrides?.[projectPath])
+      return;
+    delete plugin.projectOverrides[projectPath];
+    if (Object.keys(plugin.projectOverrides).length === 0) {
+      delete plugin.projectOverrides;
+    }
+  });
+  const secrets = new SecretsManager;
+  const syncConfig = loadConfig();
+  const summary = syncAllClients(syncConfig, secrets);
+  await mutateConfig((freshConfig) => {
+    persistSyncState(summary, freshConfig);
+  });
+}
+async function approvePluginComponent(nameOrId, component) {
+  const manager = new PluginManager;
+  const config = loadConfig(manager["configPath"]);
+  const id = resolvePluginId(config, nameOrId);
+  await manager.approveComponent(id, component);
+}
+async function getPluginStatus(nameOrId) {
+  const manager = new PluginManager;
+  if (nameOrId) {
+    const config = loadConfig(manager["configPath"]);
+    const id = resolvePluginId(config, nameOrId);
+    return manager.getPluginStatus(id);
+  }
+  const plugins = await manager.listPlugins();
+  return plugins[0] || null;
+}
+async function listPlugins() {
+  const manager = new PluginManager;
+  return manager.listPlugins();
+}
+function resolvePluginId(config, nameOrId) {
+  const plugins = config.plugins ?? {};
+  if (plugins[nameOrId])
+    return nameOrId;
+  const qualifiedMatches = Object.keys(plugins).filter((id) => {
+    const provenance = plugins[id].marketplace;
+    return provenance && `${provenance.pluginName}@${provenance.name}` === nameOrId;
+  });
+  if (qualifiedMatches.length === 1)
+    return qualifiedMatches[0];
+  const matches = Object.keys(plugins).filter((id) => plugins[id].name === nameOrId);
+  if (matches.length === 1)
+    return matches[0];
+  if (matches.length === 0) {
+    throw new Error(`Plugin "${nameOrId}" not found. Available: ${Object.values(plugins).map((p) => `${p.name} (${p.id})`).join(", ") || "none"}`);
+  }
+  throw new Error(`Multiple plugins match "${nameOrId}": ${matches.join(", ")}. Use the full id (<name>@<sha8>).`);
+}
+async function pluginConfigSet(nameOrId, key, value, projectPath) {
+  const manager = new PluginManager;
+  const configPath = manager["configPath"];
+  await mutateConfig((config) => {
+    const id = resolvePluginId(config, nameOrId);
+    const plugin = config.plugins?.[id];
+    if (!plugin)
+      throw new Error(`Plugin ${id} not found`);
+    if (projectPath) {
+      if (!plugin.projectOverrides)
+        plugin.projectOverrides = {};
+      if (!plugin.projectOverrides[projectPath])
+        plugin.projectOverrides[projectPath] = {};
+      if (!plugin.projectOverrides[projectPath].config)
+        plugin.projectOverrides[projectPath].config = {};
+      plugin.projectOverrides[projectPath].config[key] = value;
+    } else {
+      if (!plugin.config)
+        plugin.config = {};
+      plugin.config[key] = value;
+    }
+  }, configPath);
+}
+async function pluginSync() {
+  const config = loadConfig();
+  const secrets = new SecretsManager;
+  const summary = syncAllClients(config, secrets);
+  await mutateConfig((freshConfig) => {
+    persistSyncState(summary, freshConfig);
+  });
+}
+async function preparePlugin(name) {
+  const manager = new PluginManager;
+  await manager.preparePlugin(name);
+}
+
+export { mutateConfig, mutateProjectConfig, mutateActiveConfig, listSkills, getSkill, saveSkill, deleteSkill, prunePluginProjections, pruneAllPluginProjections, syncPluginsToClient, APP_VERSION, getAdapters, loadManagedIndex, getGatewayUrl, syncAllClients, persistSyncState, PluginCache, readManifest, discoverComponents, hasManifest, resolvePluginVars, PluginDataManager, PluginLifecycle, parseSource, PluginManager, inspectPlugin, installPlugin, updatePlugin, uninstallPlugin, enablePlugin, disablePlugin, setPluginProjectOverride, resetPluginProjectOverride, approvePluginComponent, getPluginStatus, listPlugins, resolvePluginId, pluginConfigSet, pluginSync, preparePlugin };