@kwonye/mcpx 0.1.90 → 0.1.93

package/dist/cli-kwyp9ywh.js

@@ -0,0 +1,1948 @@
+import {
+  saveConfig
+} from "./cli-np0wwh6m.js";
+import {
+  ensureGatewayToken
+} from "./cli-8vxva0cb.js";
+import {
+  ensureDir,
+  getManagedIndexPath,
+  getSkillsDir,
+  homeDir,
+  readJsonFile,
+  sha256,
+  writeJsonAtomic
+} from "./cli-zjepj3sj.js";
+import {
+  isServerEnabled
+} from "./cli-s4gspqdf.js";
+
+// src/core/skills.ts
+import fs from "node:fs";
+import path from "node:path";
+function listSkills() {
+  const skillsDir = getSkillsDir();
+  if (!fs.existsSync(skillsDir)) {
+    return [];
+  }
+  const files = fs.readdirSync(skillsDir);
+  const skills = [];
+  for (const file of files) {
+    if (file.endsWith(".md")) {
+      const id = path.basename(file, ".md");
+      const content = fs.readFileSync(path.join(skillsDir, file), "utf-8");
+      skills.push({ id, content });
+    }
+  }
+  return skills;
+}
+function getSkill(id) {
+  const skillsDir = getSkillsDir();
+  const filePath = path.join(skillsDir, `${id}.md`);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  return { id, content };
+}
+function saveSkill(id, content) {
+  const skillsDir = getSkillsDir();
+  ensureDir(skillsDir);
+  const filePath = path.join(skillsDir, `${id}.md`);
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+function deleteSkill(id) {
+  const skillsDir = getSkillsDir();
+  const filePath = path.join(skillsDir, `${id}.md`);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+}
+
+// src/core/plugin-projections.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+var OWNERSHIP_MANIFEST = "mcpx-plugins.json";
+function loadOwnership(targetDir) {
+  const manifestPath = path2.join(targetDir, OWNERSHIP_MANIFEST);
+  if (!fs2.existsSync(manifestPath)) {
+    return { version: 1, plugins: {} };
+  }
+  try {
+    return JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+  } catch {
+    return { version: 1, plugins: {} };
+  }
+}
+function saveOwnership(targetDir, manifest) {
+  fs2.writeFileSync(path2.join(targetDir, OWNERSHIP_MANIFEST), JSON.stringify(manifest, null, 2));
+}
+function recordOwned(targetDir, pluginId, paths) {
+  ensureDir(targetDir);
+  const manifest = loadOwnership(targetDir);
+  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 = path2.join(targetDir, p);
+    try {
+      if (fs2.existsSync(fullPath)) {
+        fs2.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 nsName(pluginName, id) {
+  return `${pluginName}__${id}`;
+}
+function syncClaude(plugins) {
+  const targetBase = path2.join(homeDir(), ".claude", "skills");
+  const projectedDirs = [];
+  const unsupported = [];
+  for (const plugin of plugins) {
+    if (!plugin.enabled)
+      continue;
+    const targetDir = path2.join(targetBase, plugin.pluginName);
+    ensureDir(targetDir);
+    const mcpJsonSrc = path2.join(plugin.pluginRoot, ".mcp.json");
+    const mcpJsonDest = path2.join(targetDir, ".mcp.json");
+    copyPluginDir(plugin.pluginRoot, targetDir, [".mcp.json", ".git"]);
+    if (fs2.existsSync(mcpJsonDest)) {
+      fs2.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 syncCodex(plugins) {
+  const targetBase = path2.join(homeDir(), ".codex", "skills");
+  const projectedDirs = [];
+  const unsupported = ["hooks", "agents"];
+  for (const plugin of plugins) {
+    if (!plugin.enabled || !plugin.components.skills)
+      continue;
+    ensureDir(targetBase);
+    const owned = [];
+    for (const skill of plugin.skills) {
+      const targetDir = path2.join(targetBase, nsName(plugin.pluginName, skill.id));
+      ensureDir(targetDir);
+      copyFileOrDir(skill.path, path2.join(targetDir, "SKILL.md"));
+      owned.push(nsName(plugin.pluginName, skill.id));
+      projectedDirs.push(targetDir);
+    }
+    recordOwned(targetBase, plugin.pluginId, owned);
+  }
+  return {
+    clientId: "codex",
+    status: "SYNCED",
+    projectedDirs,
+    unsupported
+  };
+}
+function syncCursor(plugins) {
+  const skillsBase = path2.join(homeDir(), ".cursor", "skills");
+  const commandsBase = path2.join(homeDir(), ".cursor", "commands");
+  const projectedDirs = [];
+  const unsupported = ["hooks", "agents"];
+  const ownedSkills = [];
+  const ownedCommands = [];
+  for (const plugin of plugins) {
+    if (!plugin.enabled)
+      continue;
+    if (plugin.components.skills) {
+      ensureDir(skillsBase);
+      for (const skill of plugin.skills) {
+        const targetDir = path2.join(skillsBase, nsName(plugin.pluginName, skill.id));
+        ensureDir(targetDir);
+        copyFileOrDir(skill.path, path2.join(targetDir, "SKILL.md"));
+        ownedSkills.push(nsName(plugin.pluginName, skill.id));
+        projectedDirs.push(targetDir);
+      }
+    }
+    if (plugin.components.commands) {
+      ensureDir(commandsBase);
+      for (const cmd of plugin.commands) {
+        const targetPath = path2.join(commandsBase, `${nsName(plugin.pluginName, cmd.id)}.md`);
+        copyFileOrDir(cmd.path, targetPath);
+        ownedCommands.push(`${nsName(plugin.pluginName, cmd.id)}.md`);
+        projectedDirs.push(targetPath);
+      }
+    }
+    if (ownedSkills.length > 0)
+      recordOwned(skillsBase, plugin.pluginId, ownedSkills);
+    if (ownedCommands.length > 0)
+      recordOwned(commandsBase, plugin.pluginId, ownedCommands);
+  }
+  return {
+    clientId: "cursor",
+    status: "SYNCED",
+    projectedDirs,
+    unsupported
+  };
+}
+function syncVsCode(plugins) {
+  const skillsBase = path2.join(homeDir(), ".copilot", "skills");
+  const projectedDirs = [];
+  const unsupported = ["hooks", "agents"];
+  for (const plugin of plugins) {
+    if (!plugin.enabled || !plugin.components.skills)
+      continue;
+    ensureDir(skillsBase);
+    const owned = [];
+    for (const skill of plugin.skills) {
+      const targetDir = path2.join(skillsBase, nsName(plugin.pluginName, skill.id));
+      ensureDir(targetDir);
+      copyFileOrDir(skill.path, path2.join(targetDir, "SKILL.md"));
+      owned.push(nsName(plugin.pluginName, skill.id));
+      projectedDirs.push(targetDir);
+    }
+    recordOwned(skillsBase, plugin.pluginId, owned);
+  }
+  return {
+    clientId: "vscode",
+    status: "SYNCED",
+    projectedDirs,
+    unsupported
+  };
+}
+function syncKiro(plugins) {
+  const skillsBase = path2.join(homeDir(), ".kiro", "skills");
+  const projectedDirs = [];
+  const unsupported = ["hooks", "agents", "commands"];
+  for (const plugin of plugins) {
+    if (!plugin.enabled || !plugin.components.skills)
+      continue;
+    ensureDir(skillsBase);
+    const owned = [];
+    for (const skill of plugin.skills) {
+      const targetPath = path2.join(skillsBase, `${nsName(plugin.pluginName, skill.id)}.md`);
+      copyFileOrDir(skill.path, targetPath);
+      owned.push(`${nsName(plugin.pluginName, skill.id)}.md`);
+      projectedDirs.push(targetPath);
+    }
+    recordOwned(skillsBase, plugin.pluginId, owned);
+  }
+  return {
+    clientId: "kiro",
+    status: "SYNCED",
+    projectedDirs,
+    unsupported
+  };
+}
+function syncQwen(plugins) {
+  const skillsBase = path2.join(homeDir(), ".qwen", "skills");
+  const commandsBase = path2.join(homeDir(), ".qwen", "commands");
+  const projectedDirs = [];
+  const unsupported = ["hooks", "agents"];
+  const ownedSkills = [];
+  const ownedCommands = [];
+  for (const plugin of plugins) {
+    if (!plugin.enabled)
+      continue;
+    if (plugin.components.skills) {
+      ensureDir(skillsBase);
+      for (const skill of plugin.skills) {
+        const targetPath = path2.join(skillsBase, `${nsName(plugin.pluginName, skill.id)}.md`);
+        copyFileOrDir(skill.path, targetPath);
+        ownedSkills.push(`${nsName(plugin.pluginName, skill.id)}.md`);
+        projectedDirs.push(targetPath);
+      }
+    }
+    if (plugin.components.commands) {
+      ensureDir(commandsBase);
+      for (const cmd of plugin.commands) {
+        const targetPath = path2.join(commandsBase, `${nsName(plugin.pluginName, cmd.id)}.md`);
+        copyFileOrDir(cmd.path, targetPath);
+        ownedCommands.push(`${nsName(plugin.pluginName, cmd.id)}.md`);
+        projectedDirs.push(targetPath);
+      }
+    }
+    if (ownedSkills.length > 0)
+      recordOwned(skillsBase, plugin.pluginId, ownedSkills);
+    if (ownedCommands.length > 0)
+      recordOwned(commandsBase, plugin.pluginId, ownedCommands);
+  }
+  return {
+    clientId: "qwen",
+    status: "SYNCED",
+    projectedDirs,
+    unsupported
+  };
+}
+var CLIENT_SYNCERS = {
+  claude: syncClaude,
+  "claude-desktop": syncClaudeDesktop,
+  codex: syncCodex,
+  cursor: syncCursor,
+  vscode: syncVsCode,
+  kiro: syncKiro,
+  qwen: syncQwen
+};
+function syncPluginsToClient(clientId, plugins) {
+  const syncer = CLIENT_SYNCERS[clientId];
+  if (!syncer) {
+    return {
+      clientId,
+      status: "SKIPPED",
+      projectedDirs: [],
+      unsupported: ["mcpServers", "skills", "hooks", "agents", "commands"],
+      error: `No plugin sync implementation for ${clientId}`
+    };
+  }
+  return syncer(plugins);
+}
+function copyPluginDir(src, dest, exclude = []) {
+  ensureDir(dest);
+  const entries = fs2.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (exclude.includes(entry.name))
+      continue;
+    if (entry.name.startsWith(".") && entry.name !== ".claude-plugin")
+      continue;
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyPluginDir(srcPath, destPath, exclude);
+    } else {
+      fs2.mkdirSync(path2.dirname(destPath), { recursive: true });
+      fs2.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function copyFileOrDir(src, dest) {
+  ensureDir(path2.dirname(dest));
+  if (fs2.statSync(src).isDirectory()) {
+    copyPluginDir(src, dest);
+  } else {
+    fs2.copyFileSync(src, dest);
+  }
+}
+
+// src/adapters/claude.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { z } from "zod";
+
+// 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) {
+  if (existingValue === undefined || existingValue === null) {
+    return null;
+  }
+  if (isManagedEntry(managedIndex, clientId, entryName)) {
+    return null;
+  }
+  return `Cannot sync managed entry "${entryName}" because an unmanaged entry already exists.`;
+}
+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 syncDisabledMcpServersArray(raw, managedNames, managedEntries) {
+  const existingDisabled = (raw.disabledMcpServers ?? []).filter((name) => !managedNames.includes(name));
+  const disabledManaged = managedEntries.filter((entry) => !entry.enabled).map((entry) => entry.name);
+  raw.disabledMcpServers = [...existingDisabled, ...disabledManaged];
+}
+function syncMcpExcludedArray(raw, managedNames, managedEntries) {
+  const mcp = raw.mcp ?? {};
+  const existingExcluded = (mcp.excluded ?? []).filter((name) => !managedNames.includes(name));
+  const disabledManaged = managedEntries.filter((entry) => !entry.enabled).map((entry) => entry.name);
+  mcp.excluded = [...existingExcluded, ...disabledManaged];
+  raw.mcp = mcp;
+}
+
+// src/adapters/claude.ts
+function normalizeProjectKey(p) {
+  try {
+    return fs3.realpathSync(path3.resolve(p));
+  } catch {
+    return path3.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 = z.record(z.string(), z.string());
+var claudeEntrySchema = z.object({
+  type: z.string().optional(),
+  url: z.string().min(1).optional(),
+  headers: stringMapSchema.optional(),
+  command: z.string().min(1).optional(),
+  args: z.array(z.string()).optional(),
+  env: stringMapSchema.optional(),
+  cwd: z.string().min(1).optional(),
+  disabled: z.boolean().optional()
+}).passthrough();
+
+class ClaudeAdapter {
+  id = "claude";
+  detectConfigPath() {
+    return path3.join(homeDir(), ".claude.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 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);
+      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;
+      syncDisabledMcpServersArray(raw, managedNames, options.managedEntries);
+      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);
+    } catch (error) {
+      return errorResult(this.id, configPath, error.message);
+    }
+  }
+}
+
+// src/adapters/claude-desktop.ts
+import { execFileSync } from "node:child_process";
+import path4 from "node:path";
+import { z as z2 } from "zod";
+var stringMapSchema2 = z2.record(z2.string(), z2.string());
+var claudeDesktopEntrySchema = z2.object({
+  type: z2.string().optional(),
+  url: z2.string().min(1).optional(),
+  headers: stringMapSchema2.optional(),
+  command: z2.string().min(1).optional(),
+  args: z2.array(z2.string()).optional(),
+  env: stringMapSchema2.optional(),
+  cwd: z2.string().min(1).optional(),
+  disabled: z2.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@latest", "proxy", upstreamName] };
+}
+
+class ClaudeDesktopAdapter {
+  id = "claude-desktop";
+  detectConfigPath() {
+    if (process.platform === "linux") {
+      return path4.join(homeDir(), ".config", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "win32") {
+      return path4.join(process.env.APPDATA ?? "", "Claude", "claude_desktop_config.json");
+    }
+    return path4.join(homeDir(), "Library", "Application Support", "Claude", "claude_desktop_config.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 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);
+      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);
+    } catch (error) {
+      return errorResult(this.id, configPath, error.message);
+    }
+  }
+}
+
+// src/adapters/codex.ts
+import path5 from "node:path";
+import fs4 from "node:fs";
+import { parse, stringify } from "@iarna/toml";
+import { z as z3 } from "zod";
+var stringMapSchema3 = z3.preprocess((value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value));
+}, z3.record(z3.string(), z3.string()));
+var codexEntrySchema = z3.object({
+  enabled: z3.boolean().optional(),
+  url: z3.string().min(1).optional(),
+  headers: stringMapSchema3.optional(),
+  http_headers: stringMapSchema3.optional(),
+  command: z3.string().min(1).optional(),
+  args: z3.array(z3.string()).optional(),
+  env: stringMapSchema3.optional(),
+  cwd: z3.string().min(1).optional()
+}).passthrough();
+
+class CodexAdapter {
+  id = "codex";
+  detectConfigPath() {
+    return path5.join(homeDir(), ".codex", "config.toml");
+  }
+  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 || !fs4.existsSync(configPath)) {
+      return result;
+    }
+    const existing = fs4.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 = fs4.existsSync(configPath) ? fs4.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 serverEntries = Object.fromEntries(options.managedEntries.map((entry) => [entry.name, {
+        enabled: entry.enabled,
+        url: entry.url,
+        http_headers: entry.headers
+      }]));
+      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;
+      fs4.mkdirSync(path5.dirname(configPath), { recursive: true });
+      const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
+      fs4.writeFileSync(tmpPath, stringify(doc), { mode: 384 });
+      fs4.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/cursor.ts
+import path6 from "node:path";
+import { z as z4 } from "zod";
+var stringMapSchema4 = z4.record(z4.string(), z4.string());
+var cursorEntrySchema = z4.object({
+  type: z4.string().optional(),
+  url: z4.string().min(1).optional(),
+  headers: stringMapSchema4.optional(),
+  command: z4.string().min(1).optional(),
+  args: z4.array(z4.string()).optional(),
+  env: stringMapSchema4.optional(),
+  cwd: z4.string().min(1).optional(),
+  disabled: z4.boolean().optional()
+}).passthrough();
+
+class CursorAdapter {
+  id = "cursor";
+  detectConfigPath() {
+    return path6.join(homeDir(), ".cursor", "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 = 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);
+      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);
+    } catch (error) {
+      return errorResult(this.id, configPath, error.message);
+    }
+  }
+}
+
+// src/adapters/cline.ts
+import path7 from "node:path";
+import fs5 from "node:fs";
+import { z as z5 } from "zod";
+var HTTP_TRANSPORT_TYPES = new Set(["http", "sse", "streamableHttp"]);
+var stringMapSchema5 = z5.record(z5.string(), z5.string());
+var clineEntrySchema = z5.object({
+  type: z5.string().optional(),
+  transportType: z5.string().optional(),
+  url: z5.string().min(1).optional(),
+  headers: stringMapSchema5.optional(),
+  command: z5.string().min(1).optional(),
+  args: z5.array(z5.string()).optional(),
+  env: stringMapSchema5.optional(),
+  cwd: z5.string().min(1).optional(),
+  disabled: z5.boolean().optional()
+}).passthrough();
+function getCandidatePaths() {
+  if (process.platform === "linux") {
+    return [
+      path7.join(homeDir(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path7.join(homeDir(), ".config", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path7.join(homeDir(), ".cline", "settings", "cline_mcp_settings.json")
+    ];
+  }
+  if (process.platform === "win32") {
+    return [
+      path7.join(process.env.APPDATA ?? "", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path7.join(process.env.APPDATA ?? "", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path7.join(homeDir(), ".cline", "settings", "cline_mcp_settings.json")
+    ];
+  }
+  return [
+    path7.join(homeDir(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+    path7.join(homeDir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+    path7.join(homeDir(), ".cline", "settings", "cline_mcp_settings.json")
+  ];
+}
+
+class ClineAdapter {
+  id = "cline";
+  detectConfigPath() {
+    const candidates = getCandidatePaths();
+    for (const candidate of candidates) {
+      if (fs5.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return candidates[0] ?? null;
+  }
+  supportsHttp() {
+    return true;
+  }
+  scanForImports(_config, managedIndex) {
+    const configPath = this.detectConfigPath();
+    const result = emptyImportScan(this.id, configPath ?? undefined);
+    if (!configPath || !fs5.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 (!fs5.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 serverEntries = Object.fromEntries(options.managedEntries.map((entry) => [entry.name, {
+        type: "streamableHttp",
+        url: entry.url,
+        headers: entry.headers,
+        disabled: !entry.enabled
+      }]));
+      for (const name of managedNames) {
+        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, servers[name]);
+        if (conflict) {
+          return errorResult(this.id, configPath, conflict);
+        }
+      }
+      pruneStaleManagedEntries(options.managedIndex, this.id, servers, managedNames);
+      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);
+    } catch (error) {
+      return errorResult(this.id, configPath, error.message);
+    }
+  }
+}
+
+// src/adapters/kiro.ts
+import fs6 from "node:fs";
+import path8 from "node:path";
+import { z as z6 } from "zod";
+var stringMapSchema6 = z6.record(z6.string(), z6.string());
+var kiroEntrySchema = z6.object({
+  type: z6.string().optional(),
+  url: z6.string().min(1).optional(),
+  headers: stringMapSchema6.optional(),
+  command: z6.string().min(1).optional(),
+  args: z6.array(z6.string()).optional(),
+  env: stringMapSchema6.optional(),
+  cwd: z6.string().min(1).optional(),
+  disabled: z6.boolean().optional()
+}).passthrough();
+
+class KiroAdapter {
+  id = "kiro";
+  detectConfigPath() {
+    return path8.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.type === "sse") && 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 serverEntries = Object.fromEntries(options.managedEntries.map((entry) => [entry.name, {
+        url: entry.url,
+        headers: entry.headers,
+        disabled: !entry.enabled
+      }]));
+      for (const name of managedNames) {
+        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, servers[name]);
+        if (conflict) {
+          return errorResult(this.id, configPath, conflict);
+        }
+      }
+      pruneStaleManagedEntries(options.managedIndex, this.id, servers, managedNames);
+      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);
+    } catch (error) {
+      return errorResult(this.id, configPath, error.message);
+    }
+  }
+  syncSkills(skills) {
+    const skillsDir = path8.join(homeDir(), ".kiro", "skills");
+    if (!fs6.existsSync(skillsDir)) {
+      fs6.mkdirSync(skillsDir, { recursive: true });
+    }
+    const existingFiles = fs6.readdirSync(skillsDir);
+    const managedIds = new Set(skills.map((s) => s.id));
+    for (const file of existingFiles) {
+      if (file.endsWith(".md")) {
+        const id = path8.basename(file, ".md");
+        if (!managedIds.has(id)) {
+          fs6.unlinkSync(path8.join(skillsDir, file));
+        }
+      }
+    }
+    for (const skill of skills) {
+      const targetPath = path8.join(skillsDir, `${skill.id}.md`);
+      fs6.writeFileSync(targetPath, skill.content, "utf-8");
+    }
+  }
+}
+
+// src/adapters/opencode.ts
+import path9 from "node:path";
+import { z as z7 } from "zod";
+var stringMapSchema7 = z7.record(z7.string(), z7.string());
+var openCodeEntrySchema = z7.object({
+  type: z7.string().optional(),
+  url: z7.string().min(1).optional(),
+  headers: stringMapSchema7.optional(),
+  command: z7.union([z7.string().min(1), z7.array(z7.string())]).optional(),
+  args: z7.array(z7.string()).optional(),
+  env: stringMapSchema7.optional(),
+  environment: stringMapSchema7.optional(),
+  cwd: z7.string().min(1).optional(),
+  enabled: z7.boolean().optional()
+}).passthrough();
+
+class OpenCodeAdapter {
+  id = "opencode";
+  detectConfigPath() {
+    return path9.join(homeDir(), ".config", "opencode", "opencode.json");
+  }
+  supportsHttp() {
+    return true;
+  }
+  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 serverEntries = Object.fromEntries(options.managedEntries.map((entry) => [entry.name, {
+        type: "remote",
+        url: entry.url,
+        headers: entry.headers,
+        enabled: entry.enabled
+      }]));
+      for (const name of managedNames) {
+        const conflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, mcp[name]);
+        if (conflict) {
+          return errorResult(this.id, configPath, conflict);
+        }
+      }
+      pruneStaleManagedEntries(options.managedIndex, this.id, mcp, managedNames);
+      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);
+    } catch (error) {
+      return errorResult(this.id, configPath, error.message);
+    }
+  }
+}
+
+// src/adapters/vscode.ts
+import path10 from "node:path";
+import { z as z8 } from "zod";
+var stringMapSchema8 = z8.record(z8.string(), z8.string());
+var vscodeEntrySchema = z8.object({
+  type: z8.string().optional(),
+  url: z8.string().min(1).optional(),
+  headers: stringMapSchema8.optional(),
+  command: z8.string().min(1).optional(),
+  args: z8.array(z8.string()).optional(),
+  env: stringMapSchema8.optional(),
+  cwd: z8.string().min(1).optional(),
+  disabled: z8.boolean().optional()
+}).passthrough();
+
+class VsCodeAdapter {
+  id = "vscode";
+  detectConfigPath() {
+    if (process.platform === "linux") {
+      return path10.join(homeDir(), ".config", "Code", "User", "mcp.json");
+    }
+    if (process.platform === "win32") {
+      return path10.join(process.env.APPDATA ?? "", "Code", "User", "mcp.json");
+    }
+    return path10.join(homeDir(), "Library", "Application Support", "Code", "User", "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.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);
+      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(options.managedEntries.map((entry) => [
+        entry.name,
+        JSON.stringify({ type: "http", url: entry.url, headers: entry.headers, enabled: entry.enabled })
+      ])));
+      return okResult(this.id, configPath);
+    } catch (error) {
+      return errorResult(this.id, configPath, error.message);
+    }
+  }
+}
+
+// src/adapters/qwen.ts
+import fs7 from "node:fs";
+import path11 from "node:path";
+import { z as z9 } from "zod";
+var stringMapSchema9 = z9.record(z9.string(), z9.string());
+var qwenEntrySchema = z9.object({
+  httpUrl: z9.string().min(1).optional(),
+  url: z9.string().min(1).optional(),
+  headers: stringMapSchema9.optional(),
+  command: z9.string().min(1).optional(),
+  args: z9.array(z9.string()).optional(),
+  env: stringMapSchema9.optional(),
+  cwd: z9.string().min(1).optional(),
+  disabled: z9.boolean().optional()
+}).passthrough();
+
+class QwenAdapter {
+  id = "qwen";
+  detectConfigPath() {
+    return path11.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.candidates.push({
+          clientId: this.id,
+          configPath,
+          sourceEntryName: name,
+          serverName: name,
+          spec: {
+            transport: "http",
+            url: entry.url,
+            headers: entry.headers,
+            enabled: !(entry.disabled === true || excludedSet.has(name))
+          }
+        });
+        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 serverEntries = Object.fromEntries(options.managedEntries.map((entry) => [entry.name, {
+        httpUrl: entry.url,
+        headers: entry.headers
+      }]));
+      const topLevelServers = raw.mcpServers ?? {};
+      removeSourceEntries(topLevelServers, options.sourceEntriesToRemove);
+      for (const name of managedNames) {
+        const topLevelConflict = ensureManagedEntryWritable(options.managedIndex, this.id, name, topLevelServers[name]);
+        if (topLevelConflict) {
+          return errorResult(this.id, configPath, topLevelConflict);
+        }
+      }
+      pruneStaleManagedEntries(options.managedIndex, this.id, topLevelServers, managedNames);
+      for (const [name, entry] of Object.entries(serverEntries)) {
+        topLevelServers[name] = entry;
+      }
+      raw.mcpServers = topLevelServers;
+      syncMcpExcludedArray(raw, managedNames, options.managedEntries);
+      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);
+    } catch (error) {
+      return errorResult(this.id, configPath, error.message);
+    }
+  }
+  syncSkills(skills) {
+    const skillsDir = path11.join(homeDir(), ".qwen", "skills");
+    if (!fs7.existsSync(skillsDir)) {
+      fs7.mkdirSync(skillsDir, { recursive: true });
+    }
+    const existingFiles = fs7.readdirSync(skillsDir);
+    const managedIds = new Set(skills.map((s) => s.id));
+    for (const file of existingFiles) {
+      if (file.endsWith(".md")) {
+        const id = path11.basename(file, ".md");
+        if (!managedIds.has(id)) {
+          fs7.unlinkSync(path11.join(skillsDir, file));
+        }
+      }
+    }
+    for (const skill of skills) {
+      const targetPath = path11.join(skillsDir, `${skill.id}.md`);
+      fs7.writeFileSync(targetPath, skill.content, "utf-8");
+    }
+  }
+}
+
+// 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
+  ];
+}
+
+// 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/sync.ts
+function getGatewayUrl(config) {
+  return `http://127.0.0.1:${config.gateway.port}/mcp`;
+}
+function buildProjectScopes(config) {
+  const globallyEnabled = new Set(Object.entries(config.servers).filter(([, spec]) => isServerEnabled(spec)).map(([name]) => name));
+  return Object.values(config.projects ?? {}).map((project) => {
+    const disabledServerNames = (project.disabledServers ?? []).filter((name) => globallyEnabled.has(name)).map((name) => managedGatewayEntryName(name));
+    return { path: project.path, disabledServerNames };
+  });
+}
+function buildManagedEntries(config, gatewayUrl, localToken) {
+  const entries = Object.entries(config.servers);
+  return entries.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 syncAllClients(config, secrets, targetClients) {
+  const adapters = getAdapters();
+  const managedIndexPath = getManagedIndexPath();
+  const managedIndex = loadManagedIndex(managedIndexPath);
+  const filteredAdapters = targetClients && targetClients.length > 0 ? adapters.filter((adapter) => targetClients.includes(adapter.id)) : adapters;
+  const imports = {
+    imported: [],
+    duplicates: [],
+    skipped: [],
+    conflicts: [],
+    errors: []
+  };
+  const sourceEntriesToRemove = new Map;
+  for (const adapter of filteredAdapters) {
+    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)
+      });
+    }
+  }
+  const localToken = ensureGatewayToken(config, secrets);
+  const gatewayUrl = getGatewayUrl(config);
+  const managedEntries = buildManagedEntries(config, gatewayUrl, localToken);
+  const skills = listSkills();
+  const results = [];
+  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
+  }));
+  for (const adapter of filteredAdapters) {
+    if (adapter.syncSkills) {
+      try {
+        adapter.syncSkills(skills);
+      } catch (error) {}
+    }
+    if (adapter.syncPlugins && pluginInputs.length > 0) {
+      try {
+        adapter.syncPlugins(pluginInputs);
+      } catch (error) {}
+    }
+    if (!adapter.supportsHttp()) {
+      results.push({
+        clientId: adapter.id,
+        status: "UNSUPPORTED_HTTP",
+        message: "Client adapter does not support MCP over HTTP."
+      });
+      continue;
+    }
+    const result = adapter.syncGateway(config, {
+      managedEntries,
+      managedIndex,
+      managedIndexPath,
+      sourceEntriesToRemove: Array.from(sourceEntriesToRemove.get(adapter.id) ?? []),
+      projectScopes: buildProjectScopes(config)
+    });
+    results.push(result);
+  }
+  for (const result of results) {
+    config.clients[result.clientId] = {
+      status: result.status,
+      configPath: result.configPath,
+      message: result.message,
+      lastSyncAt: new Date().toISOString()
+    };
+  }
+  saveManagedIndex(managedIndex, managedIndexPath);
+  saveConfig(config);
+  const hasErrors = results.some((result) => result.status === "ERROR") || imports.conflicts.length > 0 || imports.errors.length > 0;
+  return {
+    gatewayUrl,
+    imports,
+    results,
+    hasErrors
+  };
+}
+
+export { listSkills, getSkill, saveSkill, deleteSkill, prunePluginProjections, pruneAllPluginProjections, syncPluginsToClient, getAdapters, loadManagedIndex, getGatewayUrl, syncAllClients };