@kwonye/mcpx 0.1.104 → 0.1.106

package/dist/chunk-z1k63fa3.js

@@ -1,3760 +0,0 @@
-import {
-  loadConfig,
-  loadProjectConfig,
-  saveConfig,
-  saveProjectConfig
-} from "./chunk-wq4zd3t7.js";
-import {
-  SecretsManager,
-  ensureGatewayToken
-} from "./chunk-cz8cdmw1.js";
-import {
-  ensureDir,
-  findProjectConfigPath,
-  getConfigPath,
-  getManagedIndexPath,
-  getPluginCacheRoot,
-  getPluginDataRoot,
-  getSkillsDir,
-  homeDir,
-  readJsonFile,
-  sha256,
-  writeJsonAtomic
-} from "./chunk-cqenqnxk.js";
-import {
-  isServerEnabled
-} from "./chunk-bjw71y54.js";
-import {
-  __require
-} from "./chunk-wj4tjacg.js";
-
-// 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 { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var TMP_PREFIX = "mcpx-acquire-";
-var execFileAsync = promisify(execFile);
-
-class PluginCache {
-  cacheRoot;
-  constructor() {
-    this.cacheRoot = getPluginCacheRoot();
-    ensureDir(this.cacheRoot);
-  }
-  sourceDir(source) {
-    const key = source.type === "github" ? `github_${source.original.split("@")[0].replace(/[^a-zA-Z0-9_/-]/g, "_")}` : source.type === "npm" ? `npm_${source.original.replace(/^npm:/, "").split("@")[0].replace(/[^a-zA-Z0-9_/-]/g, "_")}` : source.type === "local" ? `local_${source.original.replace(/[^a-zA-Z0-9_/-]/g, "_")}` : source.type === "git-subdir" ? `git_subdir_${`${source.original}/${source.path ?? ""}`.replace(/[^a-zA-Z0-9_./@-]/g, "_")}` : `git_${source.original.replace(/[^a-zA-Z0-9_./@-]/g, "_")}`;
-    return path.join(this.cacheRoot, key);
-  }
-  refPath(srcDir) {
-    return path.join(srcDir, "ref.json");
-  }
-  shaDir(srcDir, sha) {
-    return path.join(srcDir, sha);
-  }
-  async resolveSha(source) {
-    const srcDir = this.sourceDir(source);
-    if (source.type === "github") {
-      const repo = source.original.replace(/^github\.com\//, "").split("@")[0];
-      const ref = source.ref || "HEAD";
-      const { stdout } = await execFileAsync("git", ["ls-remote", `https://github.com/${repo}.git`, ref], { timeout: 30000 });
-      const sha = stdout.split("\t")[0]?.trim();
-      if (!sha)
-        throw new Error(`Could not resolve ref ${ref} for ${repo}`);
-      return sha;
-    }
-    if (source.type === "git" || source.type === "git-subdir") {
-      const ref = source.ref || "HEAD";
-      const { stdout } = await execFileAsync("git", ["ls-remote", source.original, ref], { timeout: 30000 });
-      const sha = stdout.split("\t")[0]?.trim();
-      if (!sha)
-        throw new Error(`Could not resolve ref ${ref} for ${source.original}`);
-      return sha;
-    }
-    if (source.type === "local") {
-      const resolved = path.resolve(source.original);
-      if (!fs.existsSync(resolved)) {
-        throw new Error(`Local path not found: ${resolved}`);
-      }
-      return computeTreeHash(resolved);
-    }
-    if (source.type === "npm") {
-      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.replace(/^github\.com\//, "").split("@")[0]}.git` : source.original;
-      const target = source.resolvedSha || source.ref || "HEAD";
-      const tmpDir = fs.mkdtempSync(path.join(this.cacheRoot, TMP_PREFIX));
-      try {
-        await execFileAsync("git", ["init"], { cwd: tmpDir, timeout: 1e4 });
-        await execFileAsync("git", ["remote", "add", "origin", remote], { cwd: tmpDir, timeout: 1e4 });
-        await execFileAsync("git", ["fetch", "--depth", "1", "origin", target], {
-          cwd: tmpDir,
-          timeout: 60000
-        });
-        await execFileAsync("git", ["checkout", "--detach", "FETCH_HEAD"], { cwd: tmpDir, timeout: 1e4 });
-        const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
-          cwd: tmpDir,
-          timeout: 1e4
-        });
-        const actualSha = stdout.trim();
-        fs.rmSync(path.join(tmpDir, ".git"), { recursive: true, force: true });
-        const finalDest = this.shaDir(srcDir, actualSha);
-        if (fs.existsSync(finalDest)) {
-          fs.rmSync(tmpDir, { recursive: true, force: true });
-          this.updateRef(srcDir, actualSha);
-          return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
-        }
-        if (source.type === "git-subdir") {
-          if (!source.path)
-            throw new Error("git-subdir source is missing a path");
-          const subdir = path.resolve(tmpDir, source.path);
-          if (!subdir.startsWith(path.resolve(tmpDir) + path.sep) || !fs.existsSync(subdir)) {
-            throw new Error(`Plugin subdirectory not found: ${source.path}`);
-          }
-          try {
-            fs.renameSync(subdir, finalDest);
-          } catch (error) {
-            if (!fs.existsSync(finalDest))
-              throw error;
-          }
-          fs.rmSync(tmpDir, { recursive: true, force: true });
-        } else {
-          try {
-            fs.renameSync(tmpDir, finalDest);
-          } catch (error) {
-            if (!fs.existsSync(finalDest))
-              throw error;
-            return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
-          }
-        }
-        this.updateRef(srcDir, actualSha);
-        return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
-      } catch (e) {
-        if (fs.existsSync(tmpDir))
-          fs.rmSync(tmpDir, { recursive: true, force: true });
-        throw e;
-      }
-    }
-    if (source.type === "local") {
-      const resolved = path.resolve(source.original);
-      if (!fs.existsSync(resolved)) {
-        throw new Error(`Local path not found: ${resolved}`);
-      }
-      copyDirSync(resolved, destDir);
-      this.updateRef(srcDir, sha);
-      return { source: source.original, name: pluginName, sha, root: destDir };
-    }
-    if (source.type === "npm") {
-      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 { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-var execFileAsync2 = promisify2(execFile2);
-
-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) {
-          await execFileAsync2("npm", ["install", "--production", "--ignore-scripts"], {
-            cwd: pluginRoot,
-            timeout: 120000
-          });
-        }
-      } catch {}
-    }
-    const reqPath = path3.join(pluginRoot, "requirements.txt");
-    if (fs3.existsSync(reqPath)) {
-      try {
-        await execFileAsync2("pip", ["install", "-r", reqPath], {
-          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
-    };
-  }
-  throw new Error(`Unrecognized plugin source: ${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 AGENT_PLUGIN_JSON_REL = "plugin.json";
-var MCP_JSON_RELS = ["mcp.json", ".mcp.json"];
-var HOOKS_JSON_REL = path4.join("hooks", "hooks.json");
-var SKILLS_DIR = "skills";
-var COMMANDS_DIR = "commands";
-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 [AGENT_PLUGIN_JSON_REL, 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) : MCP_JSON_RELS.map((rel) => path4.join(pluginRoot, rel)).find(fs4.existsSync) ?? null;
-  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(/\$\{CLAUDE_PLUGIN_DATA\}/g, dataDir).replace(/\$\{MCPX_PLUGIN_ROOT\}/g, pluginRoot).replace(/\$\{MCPX_PLUGIN_DATA\}/g, dataDir).replace(/\$\{DATA\}/g, dataDir).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, pluginRoot);
-}
-
-// src/core/config-store.ts
-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;
-var inProcessQueues = new Map;
-function getLockPath(filePath) {
-  return `${filePath}.lock`;
-}
-function acquireLock(filePath) {
-  const lockPath = getLockPath(filePath);
-  try {
-    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 = fs5.statSync(lockPath);
-      if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-        fs5.unlinkSync(lockPath);
-        return acquireLock(filePath);
-      }
-    } catch {
-      return acquireLock(filePath);
-    }
-    return false;
-  }
-}
-function releaseLock(filePath) {
-  try {
-    fs5.unlinkSync(getLockPath(filePath));
-  } catch {}
-}
-function mutateFile(filePath, load, save, fn) {
-  const prevQueue = inProcessQueues.get(filePath) ?? Promise.resolve();
-  const nextQueue = prevQueue.then(() => executeWithLock(filePath, load, save, fn), () => executeWithLock(filePath, load, save, fn));
-  inProcessQueues.set(filePath, nextQueue.catch(() => {
-    return;
-  }));
-  return nextQueue;
-}
-async function executeWithLock(filePath, load, save, fn) {
-  let acquired = false;
-  for (let attempt = 0;attempt < LOCK_MAX_RETRIES; attempt++) {
-    acquired = acquireLock(filePath);
-    if (acquired)
-      break;
-    await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
-  }
-  if (!acquired) {
-    throw new Error(`Could not acquire lock for ${filePath}.`);
-  }
-  try {
-    const data = load(filePath);
-    const result = await fn(data);
-    save(data, filePath);
-    return result;
-  } finally {
-    releaseLock(filePath);
-  }
-}
-function mutateConfig(fn, configPath) {
-  return mutateFile(configPath ?? getConfigPath(), loadConfig, saveConfig, fn);
-}
-function mutateProjectConfig(projectConfigPath, fn) {
-  return mutateFile(projectConfigPath, (p) => loadProjectConfig(p), saveProjectConfig, fn);
-}
-async function mutateActiveConfig(options, mutator) {
-  const globalPath = getConfigPath();
-  if (!options.global) {
-    const projectConfigPath = findProjectConfigPath();
-    if (options.local) {
-      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 = {
-          ...globalConfig,
-          servers: { ...globalConfig.servers, ...projectConfig.servers }
-        };
-        const mutatorResult = await mutator(mergedConfig, { type: "project", projectPath });
-        const localServers = {};
-        for (const [name, spec] of Object.entries(mergedConfig.servers)) {
-          if (!(name in globalConfig.servers)) {
-            localServers[name] = spec;
-          }
-        }
-        projectConfig.servers = localServers;
-        return mutatorResult;
-      });
-      return { type: "project", configPath: localPath, projectPath, result: result2 };
-    }
-    if (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 };
-    }
-  }
-  const result = await mutateConfig((config) => mutator(config, { type: "global" }), globalPath);
-  return { type: "global", configPath: globalPath, result };
-}
-
-// 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];
-  }
-}
-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 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 z4 } from "zod";
-
-// src/core/plugin-projections.ts
-import fs6 from "node:fs";
-import path6 from "node:path";
-var OWNERSHIP_MANIFEST = "mcpx-plugins.json";
-function loadOwnership(targetDir) {
-  const manifestPath2 = path6.join(targetDir, OWNERSHIP_MANIFEST);
-  if (!fs6.existsSync(manifestPath2)) {
-    return { version: 1, plugins: {} };
-  }
-  try {
-    return JSON.parse(fs6.readFileSync(manifestPath2, "utf8"));
-  } catch {
-    console.error(`[mcpx] Warning: corrupt plugin ownership manifest at ${manifestPath2}, resetting`);
-    return { version: 1, plugins: {} };
-  }
-}
-function saveOwnership(targetDir, manifest) {
-  ensureDir(targetDir);
-  fs6.writeFileSync(path6.join(targetDir, OWNERSHIP_MANIFEST), JSON.stringify(manifest, null, 2));
-}
-function recordOwned(targetDir, pluginId, paths) {
-  const manifest = loadOwnership(targetDir);
-  const previous = manifest.plugins[pluginId]?.paths ?? [];
-  const next = new Set(paths);
-  for (const stale of previous) {
-    if (next.has(stale))
-      continue;
-    const stalePath = path6.join(targetDir, stale);
-    try {
-      assertWithinBase(targetDir, stalePath);
-      fs6.rmSync(stalePath, { recursive: true, force: true });
-    } catch {}
-  }
-  manifest.plugins[pluginId] = {
-    pluginId,
-    paths,
-    installedAt: new Date().toISOString()
-  };
-  saveOwnership(targetDir, manifest);
-}
-function removeOwned(targetDir, pluginId) {
-  const manifest = loadOwnership(targetDir);
-  const entry = manifest.plugins[pluginId];
-  if (entry) {
-    delete manifest.plugins[pluginId];
-    saveOwnership(targetDir, manifest);
-    return entry.paths;
-  }
-  return [];
-}
-function prunePluginProjections(targetDir, pluginId) {
-  const paths = removeOwned(targetDir, pluginId);
-  for (const p of paths) {
-    const fullPath = path6.join(targetDir, p);
-    try {
-      assertWithinBase(targetDir, fullPath);
-      if (fs6.existsSync(fullPath)) {
-        fs6.rmSync(fullPath, { recursive: true, force: true });
-      }
-    } catch {}
-  }
-}
-function pruneAllPluginProjections(targetDir) {
-  const manifest = loadOwnership(targetDir);
-  for (const [pluginId] of Object.entries(manifest.plugins)) {
-    prunePluginProjections(targetDir, pluginId);
-  }
-}
-function pruneUnlistedPlugins(targetDir, keepPluginIds) {
-  const manifest = loadOwnership(targetDir);
-  const keep = new Set(keepPluginIds);
-  for (const [pluginId] of Object.entries(manifest.plugins)) {
-    if (!keep.has(pluginId)) {
-      prunePluginProjections(targetDir, pluginId);
-    }
-  }
-}
-function nsName(pluginName, id) {
-  return `${pluginName}__${id}`;
-}
-function assertWithinBase(base, target) {
-  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})`);
-  }
-}
-function isComponentApproved(plugin, component) {
-  const approval = plugin.approvals?.[component];
-  if (approval === false)
-    return false;
-  if (approval === true)
-    return true;
-  if (component === "hooks")
-    return false;
-  if (component === "mcpServers")
-    return plugin.components.mcpServers;
-  return plugin.components[component] ?? false;
-}
-function syncClaude(plugins) {
-  const targetBase = path6.join(homeDir(), ".claude", "skills");
-  const projectedDirs = [];
-  const unsupported = [];
-  const skippedUnapproved = [];
-  for (const plugin of plugins) {
-    if (!plugin.enabled)
-      continue;
-    if (!isComponentApproved(plugin, "skills")) {
-      skippedUnapproved.push(`${plugin.pluginName}:skills`);
-      continue;
-    }
-    const targetDir = path6.join(targetBase, plugin.pluginName);
-    assertWithinBase(targetBase, targetDir);
-    ensureDir(targetDir);
-    const mcpJsonSrc = path6.join(plugin.pluginRoot, ".mcp.json");
-    const mcpJsonDest = path6.join(targetDir, ".mcp.json");
-    copyPluginDir(plugin.pluginRoot, targetDir, [".mcp.json", ".git"]);
-    if (fs6.existsSync(mcpJsonDest)) {
-      fs6.rmSync(mcpJsonDest, { recursive: true, force: true });
-    }
-    projectedDirs.push(targetDir);
-    recordOwned(targetBase, plugin.pluginId, [plugin.pluginName]);
-  }
-  return {
-    clientId: "claude",
-    status: projectedDirs.length > 0 || plugins.length === 0 ? "SYNCED" : "SKIPPED",
-    projectedDirs,
-    unsupported: []
-  };
-}
-function syncClaudeDesktop(plugins) {
-  const unsupported = ["skills", "hooks", "agents", "commands"];
-  return {
-    clientId: "claude-desktop",
-    status: plugins.length > 0 ? "SYNCED" : "SKIPPED",
-    projectedDirs: [],
-    unsupported
-  };
-}
-function syncNamespacedComponents(config, plugins) {
-  const projectedDirs = [];
-  const errors = [];
-  const syncSkills = (plugin) => {
-    if (!config.skillsBase)
-      return;
-    if (!plugin.components.skills || !isComponentApproved(plugin, "skills")) {
-      if (fs6.existsSync(config.skillsBase)) {
-        recordOwned(config.skillsBase, plugin.pluginId, []);
-      }
-      return;
-    }
-    ensureDir(config.skillsBase);
-    const owned = [];
-    for (const skill of plugin.skills) {
-      try {
-        const name = nsName(plugin.pluginName, skill.id);
-        const targetDir = path6.join(config.skillsBase, name);
-        assertWithinBase(config.skillsBase, targetDir);
-        ensureDir(targetDir);
-        copyFileOrDir(skill.path, path6.join(targetDir, "SKILL.md"));
-        owned.push(name);
-        projectedDirs.push(targetDir);
-      } catch (error) {
-        errors.push(`${plugin.pluginName}/${skill.id}: ${error.message}`);
-      }
-    }
-    recordOwned(config.skillsBase, plugin.pluginId, owned);
-  };
-  const syncCommands = (plugin) => {
-    if (!config.commandsBase)
-      return;
-    if (!plugin.components.commands || !isComponentApproved(plugin, "commands")) {
-      if (fs6.existsSync(config.commandsBase)) {
-        recordOwned(config.commandsBase, plugin.pluginId, []);
-      }
-      return;
-    }
-    ensureDir(config.commandsBase);
-    const owned = [];
-    for (const command of plugin.commands) {
-      try {
-        const targetPath = path6.join(config.commandsBase, `${nsName(plugin.pluginName, command.id)}.md`);
-        assertWithinBase(config.commandsBase, targetPath);
-        copyFileOrDir(command.path, targetPath);
-        owned.push(path6.basename(targetPath));
-        projectedDirs.push(targetPath);
-      } catch (error) {
-        errors.push(`${plugin.pluginName}/${command.id}: ${error.message}`);
-      }
-    }
-    recordOwned(config.commandsBase, plugin.pluginId, owned);
-  };
-  for (const plugin of plugins) {
-    if (!plugin.enabled)
-      continue;
-    syncSkills(plugin);
-    syncCommands(plugin);
-  }
-  return {
-    clientId: config.clientId,
-    status: "SYNCED",
-    projectedDirs,
-    unsupported: config.unsupported,
-    ...errors.length > 0 ? { error: errors.join("; ") } : {}
-  };
-}
-function syncOpenCode(plugins) {
-  const unsupported = ["skills", "hooks", "agents", "commands"];
-  return {
-    clientId: "opencode",
-    status: plugins.length > 0 ? "SYNCED" : "SKIPPED",
-    projectedDirs: [],
-    unsupported
-  };
-}
-function syncPluginsToClient(clientId, plugins) {
-  const syncMap = {
-    claude: syncClaude,
-    "claude-desktop": syncClaudeDesktop,
-    codex: (plugins2) => syncNamespacedComponents({ clientId: "codex", skillsBase: path6.join(homeDir(), ".codex", "skills"), unsupported: ["hooks", "agents"] }, plugins2),
-    cursor: (plugins2) => syncNamespacedComponents({ clientId: "cursor", skillsBase: path6.join(homeDir(), ".cursor", "skills"), commandsBase: path6.join(homeDir(), ".cursor", "commands"), unsupported: ["hooks", "agents"] }, plugins2),
-    vscode: (plugins2) => syncNamespacedComponents({ clientId: "vscode", skillsBase: path6.join(homeDir(), ".copilot", "skills"), unsupported: ["hooks", "agents"] }, plugins2),
-    qwen: (plugins2) => syncNamespacedComponents({ clientId: "qwen", skillsBase: path6.join(homeDir(), ".qwen", "skills"), unsupported: ["hooks", "agents", "commands"] }, plugins2),
-    cline: (plugins2) => syncNamespacedComponents({ clientId: "cline", skillsBase: path6.join(homeDir(), ".config", "cline", "skills"), unsupported: ["hooks", "agents", "commands"] }, plugins2),
-    kiro: (plugins2) => syncNamespacedComponents({ clientId: "kiro", skillsBase: path6.join(homeDir(), ".kiro", "skills"), unsupported: ["hooks", "agents", "commands"] }, plugins2),
-    opencode: syncOpenCode
-  };
-  const syncFn = syncMap[clientId];
-  if (!syncFn) {
-    return { clientId, status: "SKIPPED", projectedDirs: [], unsupported: [] };
-  }
-  const targetBaseMap = {
-    claude: path6.join(homeDir(), ".claude", "skills"),
-    "claude-desktop": "",
-    codex: path6.join(homeDir(), ".codex", "skills"),
-    cursor: path6.join(homeDir(), ".cursor", "skills"),
-    vscode: path6.join(homeDir(), ".copilot", "skills"),
-    qwen: path6.join(homeDir(), ".qwen", "skills"),
-    cline: path6.join(homeDir(), ".config", "cline", "skills"),
-    kiro: path6.join(homeDir(), ".kiro", "skills"),
-    opencode: ""
-  };
-  const target = targetBaseMap[clientId];
-  if (target) {
-    const enabledIds = plugins.filter((p) => p.enabled).map((p) => p.pluginId);
-    pruneUnlistedPlugins(target, enabledIds);
-    if (clientId === "cursor") {
-      pruneUnlistedPlugins(path6.join(homeDir(), ".cursor", "commands"), enabledIds);
-    }
-  }
-  return syncFn(plugins);
-}
-function copyPluginDir(src, dest, exclude = [], errors) {
-  const excludeSet = new Set(exclude);
-  ensureDir(dest);
-  const entries = fs6.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    if (excludeSet.has(entry.name))
-      continue;
-    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 {
-        fs6.copyFileSync(srcPath, destPath);
-      } catch (e) {
-        errors?.push(`Failed to copy ${srcPath}: ${e.message}`);
-      }
-    }
-  }
-}
-function copyFileOrDir(src, dest, errors) {
-  try {
-    ensureDir(path6.dirname(dest));
-    if (fs6.statSync(src).isDirectory()) {
-      copyPluginDir(src, dest, [], errors);
-    } else {
-      fs6.copyFileSync(src, dest);
-    }
-  } catch (e) {
-    errors?.push(`Failed to copy ${src} -> ${dest}: ${e.message}`);
-  }
-}
-
-// src/core/skill-projections.ts
-import fs7 from "node:fs";
-import path7 from "node:path";
-import { z as z3 } from "zod";
-
-// src/core/identifiers.ts
-import { z as z2 } from "zod";
-var skillIdSchema = z2.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/);
-function validateSkillId(id) {
-  const result = skillIdSchema.safeParse(id);
-  if (!result.success) {
-    throw new Error(`Invalid skill id "${id}". Use letters, numbers, dots, underscores, and hyphens.`);
-  }
-  return id;
-}
-function normalizePluginName(name) {
-  const normalized = name.replace(/[\\/]/g, "_").replace(/^\.+/, "").replace(/[^a-zA-Z0-9._-]/g, "_");
-  if (!normalized) {
-    throw new Error(`Invalid plugin name "${name}"`);
-  }
-  return normalized;
-}
-
-// src/core/skill-projections.ts
-var OWNERSHIP_MANIFEST2 = "mcpx-skills.json";
-var ownershipSchema = z3.object({
-  version: z3.literal(1),
-  paths: z3.array(z3.string())
-});
-function assertWithinBase2(base, target) {
-  const resolvedBase = path7.resolve(base);
-  const resolvedTarget = path7.resolve(target);
-  if (resolvedTarget !== resolvedBase && !resolvedTarget.startsWith(resolvedBase + path7.sep)) {
-    throw new Error(`Refusing to access path outside projection base: ${target}`);
-  }
-}
-function loadOwnership2(targetDir) {
-  const manifestPath2 = path7.join(targetDir, OWNERSHIP_MANIFEST2);
-  if (!fs7.existsSync(manifestPath2)) {
-    return { version: 1, paths: [] };
-  }
-  try {
-    const parsed = ownershipSchema.safeParse(JSON.parse(fs7.readFileSync(manifestPath2, "utf8")));
-    if (parsed.success)
-      return parsed.data;
-  } catch {
-    console.error(`[mcpx] Warning: corrupt ownership manifest at ${manifestPath2}, resetting`);
-    return { version: 1, paths: [] };
-  }
-  return { version: 1, paths: [] };
-}
-function saveOwnership2(targetDir, manifest) {
-  ensureDir(targetDir);
-  fs7.writeFileSync(path7.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 = path7.join(targetDir, ownedPath);
-      try {
-        assertWithinBase2(targetDir, fullPath);
-        if (fs7.existsSync(fullPath)) {
-          fs7.rmSync(fullPath, { recursive: true, force: true });
-        }
-        if (layout === "dir") {
-          const dirPath = path7.join(targetDir, path7.dirname(ownedPath));
-          assertWithinBase2(targetDir, dirPath);
-          try {
-            const remaining = fs7.readdirSync(dirPath);
-            if (remaining.length === 0) {
-              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) {
-    validateSkillId(skill.id);
-    const filePath = layout === "dir" ? path7.join(targetDir, skill.id, "SKILL.md") : path7.join(targetDir, `${skill.id}.md`);
-    assertWithinBase2(targetDir, filePath);
-    ensureDir(path7.dirname(filePath));
-    fs7.writeFileSync(filePath, skill.content, "utf-8");
-  }
-  saveOwnership2(targetDir, { version: 1, paths: Array.from(newPaths) });
-}
-
-// src/adapters/claude.ts
-function normalizeProjectKey(p) {
-  try {
-    return fs8.realpathSync(path8.resolve(p));
-  } catch {
-    return path8.resolve(p);
-  }
-}
-function syncProjectDisabledArray(project, managedNames, disabledForThisProject) {
-  const existingNonManaged = (project.disabledMcpServers ?? []).filter((name) => !managedNames.includes(name));
-  const combined = [...existingNonManaged, ...disabledForThisProject];
-  if (combined.length > 0) {
-    project.disabledMcpServers = combined;
-  } else {
-    delete project.disabledMcpServers;
-  }
-}
-var stringMapSchema = z4.record(z4.string(), z4.string());
-var claudeEntrySchema = z4.object({
-  type: z4.string().optional(),
-  url: z4.string().min(1).optional(),
-  headers: stringMapSchema.optional(),
-  command: z4.string().min(1).optional(),
-  args: z4.array(z4.string()).optional(),
-  env: stringMapSchema.optional(),
-  cwd: z4.string().min(1).optional(),
-  disabled: z4.boolean().optional()
-}).passthrough();
-
-class ClaudeAdapter {
-  id = "claude";
-  detectConfigPath() {
-    return path8.join(homeDir(), ".claude.json");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  syncSkills(skills) {
-    projectSkillsToDir(path8.join(homeDir(), ".claude", "skills"), skills, "dir");
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath) {
-      return result;
-    }
-    const raw = readJsonFile(configPath, {});
-    const topLevelServers = raw.mcpServers ?? {};
-    const disabledMcpServers = new Set(raw.disabledMcpServers ?? []);
-    const projects = raw.projects ?? {};
-    for (const project of Object.values(projects)) {
-      const projectDisabled = project?.disabledMcpServers ?? [];
-      for (const name of projectDisabled) {
-        disabledMcpServers.add(name);
-      }
-    }
-    for (const [name, rawEntry] of Object.entries(topLevelServers)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = claudeEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      const isDisabled = entry.disabled === true || disabledMcpServers.has(name);
-      if ((entry.type === undefined || entry.type === "http" || entry.type === "streamable-http") && entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.headers,
-            enabled: !isDisabled
-          }
-        });
-        continue;
-      }
-      if ((entry.type === undefined || entry.type === "stdio") && entry.command && !entry.url) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.cwd,
-            enabled: !isDisabled
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve Claude config path.");
-    }
-    try {
-      const raw = readJsonFile(configPath, {});
-      const managedNames = options.managedEntries.map((entry) => entry.name);
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        type: "http",
-        url: entry.url,
-        headers: entry.headers
-      }]));
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const topLevelServers = raw.mcpServers ?? {};
-      removeSourceEntries(topLevelServers, options.sourceEntriesToRemove);
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, topLevelServers[name]));
-      for (const name of enabledManagedNames) {
-        const topLevelConflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, topLevelServers[name]);
-        if (topLevelConflict) {
-          return errorResult(this.id, configPath, topLevelConflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, topLevelServers, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        topLevelServers[name] = entry;
-      }
-      raw.mcpServers = topLevelServers;
-      purgeManagedFromDisabledArray(raw, managedNames);
-      const scopeByNormalizedPath = new Map;
-      for (const scope of options.projectScopes ?? []) {
-        scopeByNormalizedPath.set(normalizeProjectKey(scope.path), scope.disabledServerNames);
-      }
-      const projects = raw.projects ?? {};
-      for (const projectPath of Object.keys(projects)) {
-        const project = projects[projectPath] ?? {};
-        const disabledForThis = scopeByNormalizedPath.get(normalizeProjectKey(projectPath)) ?? [];
-        syncProjectDisabledArray(project, managedNames, disabledForThis);
-        projects[projectPath] = project;
-      }
-      for (const scope of options.projectScopes ?? []) {
-        if (scope.disabledServerNames.length === 0)
-          continue;
-        const normalizedKey = normalizeProjectKey(scope.path);
-        const alreadyExists = Object.keys(projects).some((p) => normalizeProjectKey(p) === normalizedKey);
-        if (!alreadyExists) {
-          projects[scope.path] = { disabledMcpServers: [...scope.disabledServerNames] };
-        }
-      }
-      raw.projects = projects;
-      writeJsonAtomic(configPath, raw);
-      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) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-}
-
-// src/adapters/claude-desktop.ts
-import { execFileSync } from "node:child_process";
-import path9 from "node:path";
-import { z as z5 } from "zod";
-
-// src/version.ts
-var APP_VERSION = "0.1.3";
-
-// src/adapters/claude-desktop.ts
-var stringMapSchema2 = z5.record(z5.string(), z5.string());
-var claudeDesktopEntrySchema = z5.object({
-  type: z5.string().optional(),
-  url: z5.string().min(1).optional(),
-  headers: stringMapSchema2.optional(),
-  command: z5.string().min(1).optional(),
-  args: z5.array(z5.string()).optional(),
-  env: stringMapSchema2.optional(),
-  cwd: z5.string().min(1).optional(),
-  disabled: z5.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();
-    if (mcpxPath)
-      return { command: mcpxPath, args: ["proxy", upstreamName] };
-  } catch {}
-  return { command: "npx", args: ["-y", `@kwonye/mcpx@${APP_VERSION}`, "proxy", upstreamName] };
-}
-
-class ClaudeDesktopAdapter {
-  id = "claude-desktop";
-  detectConfigPath() {
-    if (process.platform === "linux") {
-      return path9.join(homeDir(), ".config", "Claude", "claude_desktop_config.json");
-    }
-    if (process.platform === "win32") {
-      return path9.join(process.env.APPDATA ?? "", "Claude", "claude_desktop_config.json");
-    }
-    return path9.join(homeDir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  syncSkills(skills) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return;
-    }
-    projectSkillsToDir(path9.join(path9.dirname(configPath), "skills"), skills, "dir");
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath) {
-      return result;
-    }
-    const raw = readJsonFile(configPath, {});
-    const topLevelServers = raw.mcpServers ?? {};
-    for (const [name, rawEntry] of Object.entries(topLevelServers)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = claudeDesktopEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      if ((entry.type === undefined || entry.type === "http" || entry.type === "streamable-http") && entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.headers,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      if ((entry.type === undefined || entry.type === "stdio") && entry.command && !entry.url) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.cwd,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve Claude Desktop config path.");
-    }
-    try {
-      const raw = readJsonFile(configPath, {});
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => {
-        const { command, args } = buildProxyEntry(entry);
-        return [entry.name, { command, args }];
-      }));
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const topLevelServers = raw.mcpServers ?? {};
-      removeSourceEntries(topLevelServers, options.sourceEntriesToRemove);
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, topLevelServers[name]));
-      for (const name of enabledManagedNames) {
-        const topLevelConflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, topLevelServers[name]);
-        if (topLevelConflict) {
-          return errorResult(this.id, configPath, topLevelConflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, topLevelServers, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        topLevelServers[name] = entry;
-      }
-      raw.mcpServers = topLevelServers;
-      writeJsonAtomic(configPath, raw);
-      setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(enabledEntries.map((entry) => {
-        const { command, args } = buildProxyEntry(entry);
-        return [entry.name, JSON.stringify({ command, args })];
-      })));
-      return { ...okResult(this.id, configPath), driftedEntries: driftedNames.length > 0 ? driftedNames : undefined };
-    } catch (error) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-}
-
-// src/adapters/codex.ts
-import path10 from "node:path";
-import fs9 from "node:fs";
-import { parse, stringify } from "@iarna/toml";
-import { z as z6 } from "zod";
-var stringMapSchema3 = z6.preprocess((value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return value;
-  }
-  return Object.fromEntries(Object.entries(value));
-}, z6.record(z6.string(), z6.string()));
-var codexEntrySchema = z6.object({
-  enabled: z6.boolean().optional(),
-  url: z6.string().min(1).optional(),
-  headers: stringMapSchema3.optional(),
-  http_headers: stringMapSchema3.optional(),
-  command: z6.string().min(1).optional(),
-  args: z6.array(z6.string()).optional(),
-  env: stringMapSchema3.optional(),
-  cwd: z6.string().min(1).optional()
-}).passthrough();
-
-class CodexAdapter {
-  id = "codex";
-  detectConfigPath() {
-    return path10.join(homeDir(), ".codex", "config.toml");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  syncSkills(skills) {
-    projectSkillsToDir(path10.join(homeDir(), ".codex", "skills"), skills, "dir");
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs9.existsSync(configPath)) {
-      return result;
-    }
-    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)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = codexEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      if (entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.http_headers ?? entry.headers,
-            enabled: entry.enabled !== false
-          }
-        });
-        continue;
-      }
-      if (entry.command && !entry.url) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.cwd,
-            enabled: entry.enabled !== false
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve Codex config.toml path.");
-    }
-    try {
-      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);
-      const managedNames = options.managedEntries.map((entry) => entry.name);
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        url: entry.url,
-        http_headers: entry.headers
-      }]));
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, mcpServers[name]));
-      for (const name of enabledManagedNames) {
-        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, mcpServers[name]);
-        if (conflict) {
-          return errorResult(this.id, configPath, conflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, mcpServers, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        mcpServers[name] = entry;
-      }
-      doc.mcp_servers = mcpServers;
-      fs9.mkdirSync(path10.dirname(configPath), { recursive: true });
-      const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
-      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) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-}
-
-// src/adapters/cursor.ts
-import path11 from "node:path";
-import { z as z7 } from "zod";
-var stringMapSchema4 = z7.record(z7.string(), z7.string());
-var cursorEntrySchema = z7.object({
-  type: z7.string().optional(),
-  url: z7.string().min(1).optional(),
-  headers: stringMapSchema4.optional(),
-  command: z7.string().min(1).optional(),
-  args: z7.array(z7.string()).optional(),
-  env: stringMapSchema4.optional(),
-  cwd: z7.string().min(1).optional(),
-  disabled: z7.boolean().optional()
-}).passthrough();
-
-class CursorAdapter {
-  id = "cursor";
-  detectConfigPath() {
-    return path11.join(homeDir(), ".cursor", "mcp.json");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  syncSkills(skills) {
-    projectSkillsToDir(path11.join(homeDir(), ".cursor", "skills"), skills, "dir");
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath) {
-      return result;
-    }
-    const raw = readJsonFile(configPath, {});
-    const servers = {
-      ...raw.mcpServers ?? {}
-    };
-    for (const [name, rawEntry] of Object.entries(servers)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = cursorEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      if ((entry.type === undefined || entry.type === "http" || entry.type === "streamable-http") && entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.headers,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      if ((entry.type === undefined || entry.type === "stdio") && entry.command && !entry.url) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.cwd,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve Cursor MCP config path.");
-    }
-    try {
-      const raw = readJsonFile(configPath, {});
-      const servers = {
-        ...raw.mcpServers ?? {}
-      };
-      removeSourceEntries(servers, options.sourceEntriesToRemove);
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        type: "http",
-        url: entry.url,
-        headers: entry.headers
-      }]));
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, servers[name]));
-      for (const name of enabledManagedNames) {
-        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, servers[name]);
-        if (conflict) {
-          return errorResult(this.id, configPath, conflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, servers, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        servers[name] = entry;
-      }
-      const next = {
-        ...raw,
-        mcpServers: servers
-      };
-      writeJsonAtomic(configPath, next);
-      setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(options.managedEntries.map((entry) => [
-        entry.name,
-        JSON.stringify({ type: "http", url: entry.url, headers: entry.headers, enabled: entry.enabled })
-      ])));
-      return { ...okResult(this.id, configPath), driftedEntries: driftedNames.length > 0 ? driftedNames : undefined };
-    } catch (error) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-}
-
-// src/adapters/cline.ts
-import path12 from "node:path";
-import fs10 from "node:fs";
-import { z as z8 } from "zod";
-var HTTP_TRANSPORT_TYPES = new Set(["http", "streamableHttp"]);
-var stringMapSchema5 = z8.record(z8.string(), z8.string());
-var clineEntrySchema = z8.object({
-  type: z8.string().optional(),
-  transportType: z8.string().optional(),
-  url: z8.string().min(1).optional(),
-  headers: stringMapSchema5.optional(),
-  command: z8.string().min(1).optional(),
-  args: z8.array(z8.string()).optional(),
-  env: stringMapSchema5.optional(),
-  cwd: z8.string().min(1).optional(),
-  disabled: z8.boolean().optional()
-}).passthrough();
-function getCandidatePaths() {
-  if (process.platform === "linux") {
-    return [
-      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 [
-      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 [
-    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")
-  ];
-}
-
-class ClineAdapter {
-  id = "cline";
-  detectConfigPath() {
-    const candidates = getCandidatePaths();
-    for (const candidate of candidates) {
-      if (fs10.existsSync(candidate)) {
-        return candidate;
-      }
-    }
-    return candidates[0] ?? null;
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  syncSkills(skills) {
-    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 || !fs10.existsSync(configPath)) {
-      return result;
-    }
-    const raw = readJsonFile(configPath, {});
-    const servers = {
-      ...raw.mcpServers ?? {}
-    };
-    for (const [name, rawEntry] of Object.entries(servers)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = clineEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      const transport = entry.type ?? entry.transportType;
-      if ((transport === undefined || HTTP_TRANSPORT_TYPES.has(transport)) && entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.headers,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      if ((transport === undefined || transport === "stdio") && entry.command && !entry.url) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.cwd,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve Cline MCP config path.");
-    }
-    if (!fs10.existsSync(configPath)) {
-      return okResult(this.id, configPath, "Cline config not found; skipping sync.");
-    }
-    try {
-      const raw = readJsonFile(configPath, {});
-      const servers = {
-        ...raw.mcpServers ?? {}
-      };
-      removeSourceEntries(servers, options.sourceEntriesToRemove);
-      const managedNames = options.managedEntries.map((entry) => entry.name);
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        type: "streamableHttp",
-        url: entry.url,
-        headers: entry.headers
-      }]));
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, servers[name]));
-      for (const name of enabledManagedNames) {
-        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, servers[name]);
-        if (conflict) {
-          return errorResult(this.id, configPath, conflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, servers, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        servers[name] = entry;
-      }
-      const next = {
-        ...raw,
-        mcpServers: servers
-      };
-      writeJsonAtomic(configPath, next);
-      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) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-}
-
-// src/adapters/kiro.ts
-import path13 from "node:path";
-import { z as z9 } from "zod";
-var stringMapSchema6 = z9.record(z9.string(), z9.string());
-var kiroEntrySchema = z9.object({
-  type: z9.string().optional(),
-  url: z9.string().min(1).optional(),
-  headers: stringMapSchema6.optional(),
-  command: z9.string().min(1).optional(),
-  args: z9.array(z9.string()).optional(),
-  env: stringMapSchema6.optional(),
-  cwd: z9.string().min(1).optional(),
-  disabled: z9.boolean().optional()
-}).passthrough();
-
-class KiroAdapter {
-  id = "kiro";
-  detectConfigPath() {
-    return path13.join(homeDir(), ".kiro", "settings", "mcp.json");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath) {
-      return result;
-    }
-    const raw = readJsonFile(configPath, {});
-    const servers = {
-      ...raw.mcpServers ?? {}
-    };
-    for (const [name, rawEntry] of Object.entries(servers)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = kiroEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      if ((entry.type === undefined || entry.type === "http" || entry.type === "streamable-http") && entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.headers,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      if ((entry.type === undefined || entry.type === "stdio") && entry.command && !entry.url) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.cwd,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve Kiro MCP config path.");
-    }
-    try {
-      const raw = readJsonFile(configPath, {});
-      const servers = {
-        ...raw.mcpServers ?? {}
-      };
-      removeSourceEntries(servers, options.sourceEntriesToRemove);
-      const managedNames = options.managedEntries.map((entry) => entry.name);
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        url: entry.url,
-        headers: entry.headers
-      }]));
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, servers[name]));
-      for (const name of enabledManagedNames) {
-        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, servers[name]);
-        if (conflict) {
-          return errorResult(this.id, configPath, conflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, servers, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        servers[name] = entry;
-      }
-      const next = {
-        ...raw,
-        mcpServers: servers
-      };
-      writeJsonAtomic(configPath, next);
-      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) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-  syncSkills(skills) {
-    projectSkillsToDir(path13.join(homeDir(), ".kiro", "skills"), skills, "flat");
-  }
-}
-
-// src/adapters/opencode.ts
-import path14 from "node:path";
-import { z as z10 } from "zod";
-var stringMapSchema7 = z10.record(z10.string(), z10.string());
-var openCodeEntrySchema = z10.object({
-  type: z10.string().optional(),
-  url: z10.string().min(1).optional(),
-  headers: stringMapSchema7.optional(),
-  command: z10.union([z10.string().min(1), z10.array(z10.string())]).optional(),
-  args: z10.array(z10.string()).optional(),
-  env: stringMapSchema7.optional(),
-  environment: stringMapSchema7.optional(),
-  cwd: z10.string().min(1).optional(),
-  enabled: z10.boolean().optional()
-}).passthrough();
-
-class OpenCodeAdapter {
-  id = "opencode";
-  detectConfigPath() {
-    return path14.join(homeDir(), ".config", "opencode", "opencode.json");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  syncSkills(skills) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return;
-    }
-    projectSkillsToDir(path14.join(path14.dirname(configPath), "skills"), skills, "dir");
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath) {
-      return result;
-    }
-    const raw = readJsonFile(configPath, {});
-    const mcp = {
-      ...raw.mcp ?? {}
-    };
-    for (const [name, rawEntry] of Object.entries(mcp)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = openCodeEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      if ((entry.type === undefined || entry.type === "remote" || entry.type === "http" || entry.type === "streamable-http") && entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.headers,
-            enabled: entry.enabled !== false
-          }
-        });
-        continue;
-      }
-      if ((entry.type === undefined || entry.type === "local" || entry.type === "stdio") && entry.command && !entry.url) {
-        const commandParts = Array.isArray(entry.command) ? entry.command : [entry.command, ...entry.args ?? []];
-        if (commandParts.length === 0) {
-          result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-          continue;
-        }
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: commandParts[0],
-            args: commandParts.slice(1),
-            env: entry.environment ?? entry.env,
-            cwd: entry.cwd,
-            enabled: entry.enabled !== false
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve OpenCode config path.");
-    }
-    try {
-      const raw = readJsonFile(configPath, {});
-      const mcp = {
-        ...raw.mcp ?? {}
-      };
-      removeSourceEntries(mcp, options.sourceEntriesToRemove);
-      const managedNames = options.managedEntries.map((entry) => entry.name);
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        type: "remote",
-        url: entry.url,
-        headers: entry.headers
-      }]));
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, mcp[name]));
-      for (const name of enabledManagedNames) {
-        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, mcp[name]);
-        if (conflict) {
-          return errorResult(this.id, configPath, conflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, mcp, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        mcp[name] = entry;
-      }
-      const next = {
-        ...raw,
-        mcp
-      };
-      writeJsonAtomic(configPath, next);
-      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) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-}
-
-// src/adapters/vscode.ts
-import path15 from "node:path";
-import { z as z11 } from "zod";
-var stringMapSchema8 = z11.record(z11.string(), z11.string());
-var vscodeEntrySchema = z11.object({
-  type: z11.string().optional(),
-  url: z11.string().min(1).optional(),
-  headers: stringMapSchema8.optional(),
-  command: z11.string().min(1).optional(),
-  args: z11.array(z11.string()).optional(),
-  env: stringMapSchema8.optional(),
-  cwd: z11.string().min(1).optional(),
-  disabled: z11.boolean().optional()
-}).passthrough();
-
-class VsCodeAdapter {
-  id = "vscode";
-  detectConfigPath() {
-    if (process.platform === "linux") {
-      return path15.join(homeDir(), ".config", "Code", "User", "mcp.json");
-    }
-    if (process.platform === "win32") {
-      return path15.join(process.env.APPDATA ?? "", "Code", "User", "mcp.json");
-    }
-    return path15.join(homeDir(), "Library", "Application Support", "Code", "User", "mcp.json");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  syncSkills(skills) {
-    projectSkillsToDir(path15.join(homeDir(), ".copilot", "skills"), skills, "dir");
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath) {
-      return result;
-    }
-    const raw = readJsonFile(configPath, {});
-    const servers = {
-      ...raw.servers ?? {}
-    };
-    for (const [name, rawEntry] of Object.entries(servers)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = vscodeEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      if ((entry.type === undefined || entry.type === "http" || entry.type === "streamable-http") && entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.headers,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      if ((entry.type === undefined || entry.type === "stdio") && entry.command && !entry.url) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.cwd,
-            enabled: entry.disabled !== true
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve VS Code MCP config path.");
-    }
-    try {
-      const raw = readJsonFile(configPath, {});
-      const servers = {
-        ...raw.servers ?? {}
-      };
-      removeSourceEntries(servers, options.sourceEntriesToRemove);
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        type: "http",
-        url: entry.url,
-        headers: entry.headers
-      }]));
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, servers[name]));
-      for (const name of enabledManagedNames) {
-        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, servers[name]);
-        if (conflict) {
-          return errorResult(this.id, configPath, conflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, servers, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        servers[name] = entry;
-      }
-      const next = {
-        ...raw,
-        servers
-      };
-      writeJsonAtomic(configPath, next);
-      setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(enabledEntries.map((entry) => [
-        entry.name,
-        JSON.stringify({ type: "http", url: entry.url, headers: entry.headers })
-      ])));
-      return { ...okResult(this.id, configPath), driftedEntries: driftedNames.length > 0 ? driftedNames : undefined };
-    } catch (error) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-}
-
-// src/adapters/qwen.ts
-import path16 from "node:path";
-import { z as z12 } from "zod";
-var stringMapSchema9 = z12.record(z12.string(), z12.string());
-var qwenEntrySchema = z12.object({
-  httpUrl: z12.string().min(1).optional(),
-  url: z12.string().min(1).optional(),
-  headers: stringMapSchema9.optional(),
-  command: z12.string().min(1).optional(),
-  args: z12.array(z12.string()).optional(),
-  env: stringMapSchema9.optional(),
-  cwd: z12.string().min(1).optional(),
-  disabled: z12.boolean().optional()
-}).passthrough();
-
-class QwenAdapter {
-  id = "qwen";
-  detectConfigPath() {
-    return path16.join(homeDir(), ".qwen", "settings.json");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath) {
-      return result;
-    }
-    const raw = readJsonFile(configPath, {});
-    const excludedSet = new Set(raw.mcp?.excluded ?? []);
-    const topLevelServers = raw.mcpServers ?? {};
-    for (const [name, rawEntry] of Object.entries(topLevelServers)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = qwenEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      if (entry.httpUrl && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.httpUrl,
-            headers: entry.headers,
-            enabled: !(entry.disabled === true || excludedSet.has(name))
-          }
-        });
-        continue;
-      }
-      if (entry.url && !entry.httpUrl && !entry.command) {
-        result.skipped.push(buildImportSkip(this.id, name, "Legacy SSE transport is not supported; use Qwen's httpUrl field for MCP v2 streamable HTTP.", configPath));
-        continue;
-      }
-      if (entry.command && !entry.httpUrl) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.cwd,
-            enabled: !(entry.disabled === true || excludedSet.has(name))
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve Qwen config path.");
-    }
-    try {
-      const raw = readJsonFile(configPath, {});
-      const managedNames = options.managedEntries.map((entry) => entry.name);
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        httpUrl: entry.url,
-        headers: entry.headers
-      }]));
-      const topLevelServers = raw.mcpServers ?? {};
-      removeSourceEntries(topLevelServers, options.sourceEntriesToRemove);
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, topLevelServers[name]));
-      for (const name of enabledManagedNames) {
-        const topLevelConflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, topLevelServers[name]);
-        if (topLevelConflict) {
-          return errorResult(this.id, configPath, topLevelConflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, topLevelServers, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        topLevelServers[name] = entry;
-      }
-      raw.mcpServers = topLevelServers;
-      purgeManagedFromExcludedArray(raw, managedNames);
-      writeJsonAtomic(configPath, raw);
-      setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(options.managedEntries.map((entry) => [
-        entry.name,
-        JSON.stringify({ httpUrl: entry.url, headers: entry.headers, enabled: entry.enabled })
-      ])));
-      return { ...okResult(this.id, configPath), driftedEntries: driftedNames.length > 0 ? driftedNames : undefined };
-    } catch (error) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-  syncSkills(skills) {
-    projectSkillsToDir(path16.join(homeDir(), ".qwen", "skills"), skills, "flat");
-  }
-}
-
-// src/adapters/openclaw.ts
-import fs11 from "node:fs";
-import path17 from "node:path";
-import { z as z13 } from "zod";
-var stringMapSchema10 = z13.record(z13.string(), z13.string());
-var openclawEntrySchema = z13.object({
-  url: z13.string().min(1).optional(),
-  transport: z13.string().optional(),
-  headers: stringMapSchema10.optional(),
-  command: z13.string().min(1).optional(),
-  args: z13.array(z13.string()).optional(),
-  env: stringMapSchema10.optional(),
-  cwd: z13.string().min(1).optional(),
-  workingDirectory: z13.string().min(1).optional(),
-  auth: z13.unknown().optional()
-}).passthrough();
-
-class OpenClawAdapter {
-  id = "openclaw";
-  detectConfigPath() {
-    return process.env.OPENCLAW_CONFIG_PATH ?? path17.join(homeDir(), ".openclaw", "openclaw.json");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  syncSkills(skills) {
-    projectSkillsToDir(path17.join(homeDir(), ".openclaw", "skills"), skills, "dir");
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath) {
-      return result;
-    }
-    let raw;
-    try {
-      raw = JSON.parse(fs11.readFileSync(configPath, "utf8"));
-    } catch {
-      return result;
-    }
-    const mcpServers = {};
-    const rootMcp = raw.mcp;
-    if (rootMcp?.servers) {
-      Object.assign(mcpServers, rootMcp.servers);
-    }
-    if (raw.mcpServers) {
-      Object.assign(mcpServers, raw.mcpServers);
-    }
-    for (const [name, rawEntry] of Object.entries(mcpServers)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = openclawEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      if (entry.auth === "oauth") {
-        result.skipped.push(buildImportSkip(this.id, name, "OAuth-authenticated servers cannot be imported via mcpx.", configPath));
-        continue;
-      }
-      if (entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.headers
-          }
-        });
-        continue;
-      }
-      if (entry.command && !entry.url) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.workingDirectory ?? entry.cwd
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve OpenClaw config path.");
-    }
-    try {
-      let raw;
-      if (fs11.existsSync(configPath)) {
-        try {
-          raw = JSON.parse(fs11.readFileSync(configPath, "utf8"));
-        } catch {
-          return errorResult(this.id, configPath, "OpenClaw config contains invalid JSON (possibly JSON5). Cannot safely write.");
-        }
-      } else {
-        raw = {};
-      }
-      const rootMcp = raw.mcp ?? {};
-      const servers = rootMcp.servers ?? {};
-      removeSourceEntries(servers, options.sourceEntriesToRemove);
-      const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        url: entry.url,
-        transport: "streamable-http",
-        headers: entry.headers
-      }]));
-      const enabledManagedNames = enabledEntries.map((entry) => entry.name);
-      const driftedNames = enabledManagedNames.filter((name) => detectManagedEntryDrift(options.managedIndex, this.id, name, servers[name]));
-      for (const name of enabledManagedNames) {
-        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, servers[name]);
-        if (conflict) {
-          return errorResult(this.id, configPath, conflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, servers, enabledManagedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        servers[name] = entry;
-      }
-      rootMcp.servers = servers;
-      raw.mcp = rootMcp;
-      writeJsonAtomic(configPath, raw);
-      setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(options.managedEntries.map((entry) => [
-        entry.name,
-        JSON.stringify({ url: entry.url, transport: "streamable-http", headers: entry.headers, enabled: entry.enabled })
-      ])));
-      return { ...okResult(this.id, configPath), driftedEntries: driftedNames.length > 0 ? driftedNames : undefined };
-    } catch (error) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-}
-
-// src/adapters/hermes.ts
-import fs12 from "node:fs";
-import path18 from "node:path";
-import YAML from "yaml";
-import { z as z14 } from "zod";
-var stringMapSchema11 = z14.record(z14.string(), z14.string());
-var hermesEntrySchema = z14.object({
-  url: z14.string().min(1).optional(),
-  headers: stringMapSchema11.optional(),
-  command: z14.string().min(1).optional(),
-  args: z14.array(z14.string()).optional(),
-  env: stringMapSchema11.optional(),
-  auth: z14.unknown().optional(),
-  enabled: z14.boolean().optional(),
-  timeout: z14.number().optional(),
-  tools: z14.array(z14.string()).optional()
-}).passthrough();
-
-class HermesAdapter {
-  id = "hermes";
-  detectConfigPath() {
-    return path18.join(homeDir(), ".hermes", "config.yaml");
-  }
-  supportsHttp() {
-    return true;
-  }
-  syncPlugins(plugins) {
-    return syncPluginsToClient(this.id, plugins);
-  }
-  syncSkills(skills) {
-    projectSkillsToDir(path18.join(homeDir(), ".hermes", "skills"), skills, "dir");
-  }
-  scanForImports(_config, managedIndex) {
-    const configPath = this.detectConfigPath();
-    const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs12.existsSync(configPath)) {
-      return result;
-    }
-    const existing = fs12.readFileSync(configPath, "utf8");
-    const doc = YAML.parse(existing) ?? {};
-    const mcpServers = doc.mcp_servers ?? {};
-    for (const [name, rawEntry] of Object.entries(mcpServers)) {
-      if (isManagedGatewayProjection(name) || managedIndex.managed[this.id]?.entries?.[name]) {
-        continue;
-      }
-      const parsed = hermesEntrySchema.safeParse(rawEntry);
-      if (!parsed.success) {
-        result.skipped.push(buildImportSkip(this.id, name, "Entry could not be mapped to an mcpx server.", configPath));
-        continue;
-      }
-      const entry = parsed.data;
-      if (entry.auth === "oauth") {
-        result.skipped.push(buildImportSkip(this.id, name, "OAuth-authenticated servers cannot be imported via mcpx.", configPath));
-        continue;
-      }
-      if (entry.url && !entry.command) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "http",
-            url: entry.url,
-            headers: entry.headers,
-            enabled: entry.enabled !== false
-          }
-        });
-        continue;
-      }
-      if (entry.command && !entry.url) {
-        result.candidates.push({
-          clientId: this.id,
-          configPath,
-          sourceEntryName: name,
-          serverName: name,
-          spec: {
-            transport: "stdio",
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            enabled: entry.enabled !== false
-          }
-        });
-        continue;
-      }
-      result.skipped.push(buildImportSkip(this.id, name, "Entry must define exactly one transport that mcpx supports.", configPath));
-    }
-    return result;
-  }
-  syncGateway(_config, options) {
-    const configPath = this.detectConfigPath();
-    if (!configPath) {
-      return errorResult(this.id, undefined, "Unable to resolve Hermes config.yaml path.");
-    }
-    try {
-      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);
-      const managedNames = options.managedEntries.map((entry) => entry.name);
-      const serverEntries = Object.fromEntries(options.managedEntries.map((entry) => [entry.name, {
-        url: entry.url,
-        headers: entry.headers,
-        enabled: entry.enabled
-      }]));
-      for (const name of managedNames) {
-        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, mcpServers[name]);
-        if (conflict) {
-          return errorResult(this.id, configPath, conflict);
-        }
-      }
-      pruneStaleManagedEntries(options.managedIndex, this.id, mcpServers, managedNames);
-      for (const [name, entry] of Object.entries(serverEntries)) {
-        mcpServers[name] = entry;
-      }
-      doc.mcp_servers = mcpServers;
-      fs12.mkdirSync(path18.dirname(configPath), { recursive: true });
-      const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
-      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) {
-      return errorResult(this.id, configPath, error.message);
-    }
-  }
-}
-
-// src/adapters/index.ts
-function getAdapters() {
-  return [
-    new ClaudeAdapter,
-    new ClaudeDesktopAdapter,
-    new CodexAdapter,
-    new CursorAdapter,
-    new ClineAdapter,
-    new OpenCodeAdapter,
-    new KiroAdapter,
-    new VsCodeAdapter,
-    new QwenAdapter,
-    new OpenClawAdapter,
-    new HermesAdapter
-  ];
-}
-
-// src/core/managed-index.ts
-function defaultManagedIndex() {
-  return {
-    schemaVersion: 1,
-    managed: {}
-  };
-}
-function loadManagedIndex(filePath = getManagedIndexPath()) {
-  const raw = readJsonFile(filePath, defaultManagedIndex());
-  if (!raw || typeof raw !== "object") {
-    return defaultManagedIndex();
-  }
-  if (raw.schemaVersion !== 1) {
-    return defaultManagedIndex();
-  }
-  return raw;
-}
-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");
-      try {
-        const content = fs13.readFileSync(path19.join(skillsDir, file), "utf-8");
-        skills.push({ id, content });
-      } catch {
-        console.error(`[mcpx] Warning: could not read skill ${file}`);
-      }
-    }
-  }
-  return skills;
-}
-function getSkill(id) {
-  validateSkillId(id);
-  const skillsDir = getSkillsDir();
-  const filePath = path19.join(skillsDir, `${id}.md`);
-  if (!fs13.existsSync(filePath)) {
-    return null;
-  }
-  const content = fs13.readFileSync(filePath, "utf-8");
-  return { id, content };
-}
-function saveSkill(id, content) {
-  validateSkillId(id);
-  const skillsDir = getSkillsDir();
-  ensureDir(skillsDir);
-  const filePath = path19.join(skillsDir, `${id}.md`);
-  fs13.writeFileSync(filePath, content, "utf-8");
-}
-function deleteSkill(id) {
-  validateSkillId(id);
-  const skillsDir = getSkillsDir();
-  const filePath = path19.join(skillsDir, `${id}.md`);
-  if (fs13.existsSync(filePath)) {
-    fs13.unlinkSync(filePath);
-  }
-}
-
-// src/core/managed-index-lock.ts
-import fs14 from "node:fs";
-import path20 from "node:path";
-function isStale(lockPath, maxAgeMs = 5000) {
-  try {
-    const stat = fs14.statSync(lockPath);
-    return Date.now() - stat.mtimeMs > maxAgeMs;
-  } catch {
-    return true;
-  }
-}
-function withManagedIndexLock(lockPath, fn) {
-  fs14.mkdirSync(path20.dirname(lockPath), { recursive: true });
-  const deadline = Date.now() + 5000;
-  while (true) {
-    try {
-      fs14.writeFileSync(lockPath, `${process.pid}
-`, { flag: "wx" });
-      break;
-    } catch {
-      if (isStale(lockPath)) {
-        try {
-          fs14.unlinkSync(lockPath);
-        } catch {}
-        continue;
-      }
-      if (Date.now() > deadline) {
-        throw new Error(`Timed out waiting for managed-index lock: ${lockPath}`);
-      }
-    }
-  }
-  try {
-    return fn();
-  } finally {
-    try {
-      fs14.unlinkSync(lockPath);
-    } catch {}
-  }
-}
-
-// src/core/sync.ts
-function getGatewayUrl(config) {
-  return `http://127.0.0.1:${config.gateway.port}/mcp`;
-}
-function getGatewayInternalUrl(config, pathname) {
-  const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  return `http://127.0.0.1:${config.gateway.port}${normalizedPath}`;
-}
-function buildProjectScopes(config) {
-  const globallyEnabled = new Set(Object.entries(config.servers).filter(([, spec]) => isServerEnabled(spec)).map(([name]) => name));
-  const pluginDisabledByProject = new Map;
-  for (const [, plugin] of Object.entries(config.plugins ?? {})) {
-    if (!plugin.projectOverrides)
-      continue;
-    for (const [overridePath, override] of Object.entries(plugin.projectOverrides)) {
-      const disabled = override.enabled === false || override.components?.mcpServers === false;
-      if (!disabled)
-        continue;
-      if (!pluginDisabledByProject.has(overridePath)) {
-        pluginDisabledByProject.set(overridePath, new Set);
-      }
-      for (const serverName of plugin.serverNames) {
-        pluginDisabledByProject.get(overridePath).add(managedGatewayEntryName(serverName));
-      }
-    }
-  }
-  return Object.values(config.projects ?? {}).map((project) => {
-    const projectPath = project.path;
-    const disabledServerNames = (project.disabledServers ?? []).filter((name) => globallyEnabled.has(name)).map((name) => managedGatewayEntryName(name));
-    const pluginDisabled = pluginDisabledByProject.get(projectPath);
-    if (pluginDisabled) {
-      for (const name of pluginDisabled) {
-        if (!disabledServerNames.includes(name)) {
-          disabledServerNames.push(name);
-        }
-      }
-    }
-    return { path: projectPath, disabledServerNames };
-  });
-}
-function buildManagedEntries(config, gatewayUrl, localToken) {
-  return Object.entries(config.servers).map(([name, spec]) => ({
-    name: `${name} (mcpx)`,
-    url: `${gatewayUrl}?upstream=${encodeURIComponent(name)}`,
-    headers: { Authorization: `Bearer ${localToken}` },
-    enabled: isServerEnabled(spec)
-  }));
-}
-function isClientInternalServerCommand(candidate) {
-  return candidate.spec.transport === "stdio" && /\.app\/Contents\//.test(candidate.spec.command ?? "");
-}
-function getFilteredAdapters(targetClients) {
-  const adapters = getAdapters();
-  if (targetClients && targetClients.length > 0) {
-    return adapters.filter((a) => targetClients.includes(a.id));
-  }
-  return adapters;
-}
-function runImportPhase(adapters, config, managedIndex) {
-  const imports = { imported: [], duplicates: [], skipped: [], conflicts: [], errors: [] };
-  const sourceEntriesToRemove = new Map;
-  const phaseErrors = [];
-  for (const adapter of adapters) {
-    try {
-      const scan = adapter.scanForImports(config, managedIndex);
-      imports.skipped.push(...scan.skipped);
-      for (const candidate of scan.candidates) {
-        if (isClientInternalServerCommand(candidate)) {
-          imports.skipped.push({
-            clientId: candidate.clientId,
-            configPath: candidate.configPath,
-            sourceEntryName: candidate.sourceEntryName,
-            serverName: candidate.serverName,
-            reason: "client-internal server"
-          });
-          continue;
-        }
-        const existing = config.servers[candidate.serverName];
-        if (!existing) {
-          config.servers[candidate.serverName] = candidate.spec;
-          imports.imported.push({
-            clientId: candidate.clientId,
-            configPath: candidate.configPath,
-            sourceEntryName: candidate.sourceEntryName,
-            serverName: candidate.serverName
-          });
-          if (!sourceEntriesToRemove.has(candidate.clientId)) {
-            sourceEntriesToRemove.set(candidate.clientId, new Set);
-          }
-          sourceEntriesToRemove.get(candidate.clientId).add(candidate.sourceEntryName);
-          continue;
-        }
-        if (serverSpecsEqual(existing, candidate.spec)) {
-          imports.duplicates.push({
-            clientId: candidate.clientId,
-            configPath: candidate.configPath,
-            sourceEntryName: candidate.sourceEntryName,
-            serverName: candidate.serverName
-          });
-          if (!sourceEntriesToRemove.has(candidate.clientId)) {
-            sourceEntriesToRemove.set(candidate.clientId, new Set);
-          }
-          sourceEntriesToRemove.get(candidate.clientId).add(candidate.sourceEntryName);
-          continue;
-        }
-        imports.conflicts.push({
-          clientId: candidate.clientId,
-          configPath: candidate.configPath,
-          sourceEntryName: candidate.sourceEntryName,
-          serverName: candidate.serverName,
-          message: `Server "${candidate.serverName}" already exists in mcpx with a different configuration.`
-        });
-      }
-    } catch (error) {
-      imports.errors.push({
-        clientId: adapter.id,
-        configPath: adapter.detectConfigPath() ?? undefined,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      phaseErrors.push({
-        clientId: adapter.id,
-        phase: "import",
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return { imports, sourceEntriesToRemove, phaseErrors };
-}
-function runSkillsPhase(adapters, skills) {
-  const phaseErrors = [];
-  for (const adapter of adapters) {
-    if (adapter.syncSkills) {
-      try {
-        adapter.syncSkills(skills);
-      } catch (error) {
-        phaseErrors.push({
-          clientId: adapter.id,
-          phase: "skills",
-          message: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-  }
-  return phaseErrors;
-}
-function runPluginsPhase(adapters, pluginInputs) {
-  const pluginResults = [];
-  const phaseErrors = [];
-  for (const adapter of adapters) {
-    if (adapter.syncPlugins) {
-      try {
-        const result = adapter.syncPlugins(pluginInputs);
-        if (result)
-          pluginResults.push(result);
-      } catch (error) {
-        phaseErrors.push({
-          clientId: adapter.id,
-          phase: "plugins",
-          message: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-  }
-  return { pluginResults, phaseErrors };
-}
-function runGatewayPhase(adapters, config, managedEntries, managedIndex, managedIndexPath, sourceEntriesToRemove, projectScopes) {
-  const results = [];
-  const phaseErrors = [];
-  for (const adapter of adapters) {
-    if (!adapter.supportsHttp()) {
-      results.push({
-        clientId: adapter.id,
-        status: "UNSUPPORTED_HTTP",
-        message: "Client adapter does not support MCP over HTTP."
-      });
-      continue;
-    }
-    try {
-      const result = adapter.syncGateway(config, {
-        managedEntries,
-        managedIndex,
-        managedIndexPath,
-        sourceEntriesToRemove: Array.from(sourceEntriesToRemove.get(adapter.id) ?? []),
-        projectScopes
-      });
-      results.push(result);
-    } catch (error) {
-      results.push({
-        clientId: adapter.id,
-        status: "ERROR",
-        message: error instanceof Error ? error.message : String(error)
-      });
-      phaseErrors.push({
-        clientId: adapter.id,
-        phase: "gateway",
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return { results, phaseErrors };
-}
-function syncAllClients(config, secrets, options) {
-  const opts = Array.isArray(options) ? { targetClients: options, importScan: false } : { importScan: false, ...options };
-  const managedIndexPath = getManagedIndexPath();
-  return withManagedIndexLock(`${managedIndexPath}.lock`, () => {
-    const managedIndex = loadManagedIndex(managedIndexPath);
-    const adapters = getFilteredAdapters(opts.targetClients);
-    const allPhaseErrors = [];
-    let imports = { imported: [], duplicates: [], skipped: [], conflicts: [], errors: [] };
-    let sourceEntriesToRemove = new Map;
-    if (opts.importScan) {
-      const importResult = runImportPhase(adapters, config, managedIndex);
-      imports = importResult.imports;
-      sourceEntriesToRemove = importResult.sourceEntriesToRemove;
-      allPhaseErrors.push(...importResult.phaseErrors ?? []);
-    }
-    const localToken = ensureGatewayToken(config, secrets);
-    const gatewayUrl = getGatewayUrl(config);
-    const managedEntries = buildManagedEntries(config, gatewayUrl, localToken);
-    const gatewayResult = runGatewayPhase(adapters, config, managedEntries, managedIndex, managedIndexPath, sourceEntriesToRemove, buildProjectScopes(config));
-    const results = gatewayResult.results;
-    allPhaseErrors.push(...gatewayResult.phaseErrors ?? []);
-    const skills = listSkills();
-    const skillsErrors = runSkillsPhase(adapters, skills);
-    allPhaseErrors.push(...skillsErrors ?? []);
-    const pluginInputs = Object.values(config.plugins ?? {}).map((p) => ({
-      pluginId: p.id,
-      pluginName: p.name,
-      pluginRoot: p.root,
-      components: p.components,
-      approvals: p.approvals ?? {},
-      enabled: p.enabled,
-      serverNames: p.serverNames,
-      skills: p.discovered.skills,
-      commands: p.discovered.commands,
-      agents: p.discovered.agents,
-      hooks: p.discovered.hooks
-    }));
-    const pluginResult = runPluginsPhase(adapters, pluginInputs);
-    const pluginResults = pluginResult.pluginResults;
-    allPhaseErrors.push(...pluginResult.phaseErrors ?? []);
-    saveManagedIndex(managedIndex, managedIndexPath);
-    const clientStates = {};
-    for (const result of results) {
-      clientStates[result.clientId] = {
-        status: result.status,
-        configPath: result.configPath,
-        message: result.message,
-        lastSyncAt: new Date().toISOString()
-      };
-    }
-    const hasErrors = results.some((r) => r.status === "ERROR") || imports.conflicts.length > 0 || imports.errors.length > 0;
-    return {
-      gatewayUrl,
-      imports,
-      results,
-      hasErrors,
-      clientStates,
-      phaseErrors: allPhaseErrors.length > 0 ? allPhaseErrors : undefined,
-      pluginResults: pluginResults.length > 0 ? pluginResults : undefined
-    };
-  });
-}
-function persistSyncState(summary, config) {
-  if (!summary.clientStates)
-    return;
-  for (const [clientId, state] of Object.entries(summary.clientStates)) {
-    config.clients[clientId] = state;
-  }
-}
-
-// 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 = normalizePluginName(options?.name || info.manifest?.name || path21.basename(info.root));
-    const pluginId = `${pluginName}@${info.sha.slice(0, 8)}`;
-    const dataDir = path21.join(getPluginDataRoot(), pluginId);
-    ensureDir(dataDir);
-    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: new URL(mcp.url).toString(), 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 = normalizePluginName(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 requiresApproval = !current.marketplace && info.components.mcpServers.length > 0;
-      const approved = !requiresApproval && current.approvals?.mcpServers !== false;
-      for (const mcp of info.components.mcpServers) {
-        const nsName2 = `${pluginName}__${mcp.id}`;
-        config.servers[nsName2] = mcp.transport === "http" && mcp.url ? { transport: "http", url: new URL(mcp.url).toString(), enabled: current.enabled && approved } : {
-          transport: "stdio",
-          command: "npx",
-          args: ["-y", "@kwonye/mcpx@latest", "plugin-host", pluginId, mcp.id],
-          enabled: current.enabled && approved
-        };
-      }
-      current.approvals = requiresApproval ? { mcpServers: false } : {};
-      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;
-      for (const name of plugin.serverNames) {
-        const server = config.servers[name];
-        if (server)
-          server.enabled = plugin.approvals?.mcpServers !== false;
-      }
-    }, this.configPath);
-    const syncConfig = loadConfig(this.configPath);
-    const summary = syncAllClients(syncConfig, this.secrets);
-    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;
-      for (const name of plugin.serverNames) {
-        const server = config.servers[name];
-        if (server)
-          server.enabled = false;
-      }
-    }, this.configPath);
-    const syncConfig = loadConfig(this.configPath);
-    const summary = syncAllClients(syncConfig, this.secrets);
-    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 resolvedId = resolvePluginId(config, pluginId);
-    const plugin = config.plugins[resolvedId];
-    if (!plugin)
-      throw new Error(`Plugin ${pluginId} not found`);
-    await this.lifecycle.prepareDependencies(resolvedId, 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("./chunk-02r7k4ax.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, getGatewayInternalUrl, 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 };
-
-//# debugId=3872A3A17F73C93764756E2164756E21