@kwonye/mcpx 0.1.91 → 0.1.94

package/dist/cli-n8vt375e.js

@@ -0,0 +1,2082 @@
+import {
+  ensureGatewayToken
+} from "./cli-tk8bggg5.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) {
+  ensureDir(targetDir);
+  fs2.writeFileSync(path2.join(targetDir, OWNERSHIP_MANIFEST), JSON.stringify(manifest, null, 2));
+}
+function recordOwned(targetDir, pluginId, paths) {
+  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 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 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 = path2.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 = 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)
+      continue;
+    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
+      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 && isComponentApproved(plugin, "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 && isComponentApproved(plugin, "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)
+      continue;
+    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
+      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 syncQwen(plugins) {
+  const targetBase = path2.join(homeDir(), ".qwen", "skills");
+  const projectedDirs = [];
+  const unsupported = ["hooks", "agents", "commands"];
+  for (const plugin of plugins) {
+    if (!plugin.enabled)
+      continue;
+    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
+      ensureDir(targetBase);
+      const owned = [];
+      for (const skill of plugin.skills) {
+        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: "qwen",
+    status: "SYNCED",
+    projectedDirs,
+    unsupported
+  };
+}
+function syncCline(plugins) {
+  const targetBase = path2.join(homeDir(), ".config", "cline", "skills");
+  const projectedDirs = [];
+  const unsupported = ["hooks", "agents", "commands"];
+  for (const plugin of plugins) {
+    if (!plugin.enabled)
+      continue;
+    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
+      ensureDir(targetBase);
+      const owned = [];
+      for (const skill of plugin.skills) {
+        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: "cline",
+    status: "SYNCED",
+    projectedDirs,
+    unsupported
+  };
+}
+function syncKiro(plugins) {
+  const targetBase = path2.join(homeDir(), ".kiro", "skills");
+  const projectedDirs = [];
+  const unsupported = ["hooks", "agents", "commands"];
+  for (const plugin of plugins) {
+    if (!plugin.enabled)
+      continue;
+    if (plugin.components.skills && isComponentApproved(plugin, "skills")) {
+      ensureDir(targetBase);
+      const owned = [];
+      for (const skill of plugin.skills) {
+        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: "kiro",
+    status: "SYNCED",
+    projectedDirs,
+    unsupported
+  };
+}
+function syncPluginsToClient(clientId, plugins) {
+  const syncMap = {
+    claude: syncClaude,
+    "claude-desktop": syncClaudeDesktop,
+    codex: syncCodex,
+    cursor: syncCursor,
+    vscode: syncVsCode,
+    qwen: syncQwen,
+    cline: syncCline,
+    kiro: syncKiro
+  };
+  const syncFn = syncMap[clientId];
+  if (!syncFn) {
+    return { clientId, status: "SKIPPED", projectedDirs: [], unsupported: [] };
+  }
+  const targetBaseMap = {
+    claude: path2.join(homeDir(), ".claude", "skills"),
+    "claude-desktop": "",
+    codex: path2.join(homeDir(), ".codex", "skills"),
+    cursor: path2.join(homeDir(), ".cursor"),
+    vscode: path2.join(homeDir(), ".copilot", "skills"),
+    qwen: path2.join(homeDir(), ".qwen", "skills"),
+    cline: path2.join(homeDir(), ".config", "cline", "skills"),
+    kiro: path2.join(homeDir(), ".kiro", "skills")
+  };
+  const target = targetBaseMap[clientId];
+  if (target) {
+    const enabledIds = plugins.filter((p) => p.enabled).map((p) => p.pluginId);
+    pruneUnlistedPlugins(target, enabledIds);
+  }
+  return syncFn(plugins);
+}
+function copyPluginDir(src, dest, exclude = []) {
+  const excludeSet = new Set(exclude);
+  ensureDir(dest);
+  const entries = fs2.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (excludeSet.has(entry.name))
+      continue;
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyPluginDir(srcPath, destPath, exclude);
+    } else if (entry.isFile()) {
+      try {
+        fs2.copyFileSync(srcPath, destPath);
+      } catch {}
+    }
+  }
+}
+function copyFileOrDir(src, dest) {
+  try {
+    ensureDir(path2.dirname(dest));
+    if (fs2.statSync(src).isDirectory()) {
+      copyPluginDir(src, dest);
+    } else {
+      fs2.copyFileSync(src, dest);
+    }
+  } catch {}
+}
+
+// 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 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;
+}
+
+// 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;
+      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);
+    } 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.filter((entry) => entry.enabled).map((entry) => [entry.name, {
+        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.filter((entry) => entry.enabled).map((entry) => [entry.name, {
+        type: "streamableHttp",
+        url: entry.url,
+        headers: entry.headers
+      }]));
+      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.filter((entry) => entry.enabled).map((entry) => [entry.name, {
+        url: entry.url,
+        headers: entry.headers
+      }]));
+      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.filter((entry) => entry.enabled).map((entry) => [entry.name, {
+        type: "remote",
+        url: entry.url,
+        headers: entry.headers
+      }]));
+      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(enabledEntries.map((entry) => [
+        entry.name,
+        JSON.stringify({ type: "http", url: entry.url, headers: entry.headers })
+      ])));
+      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;
+      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);
+    } 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) {
+  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();
+  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;
+  }
+}
+
+export { listSkills, getSkill, saveSkill, deleteSkill, prunePluginProjections, pruneAllPluginProjections, syncPluginsToClient, getAdapters, loadManagedIndex, getGatewayUrl, syncAllClients, persistSyncState };