@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-mcp-adapter/dist/config.js

@@ -1,1310 +0,0 @@
-import { chmodSync, existsSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { parse as parseToml } from "smol-toml";
-import stripJsonComments from "strip-json-comments";
-import { getAgentPath, getConfigDirName } from "./agent-dir.js";
-import { getAgentPluginSummaries, loadAgentPluginConfigs } from "./agent-plugin-loader.js";
-import { cloneBuiltInAgentPluginEntry, isBuiltInAgentPlugin, mergeBuiltInAgentPluginEntries } from "./agent-plugin-provenance.js";
-import { loadClaudePluginBundles } from "./claude-plugin-loader.js";
-import { loadPackageMcpConfigs } from "./package-mcp-loader.js";
-import { validateJevSettings } from "./jev-client.js";
-import { formatServerNamespace, isServerDisabled } from "./types.js";
-import { parseJsonWithComments, toStringRecord } from "./utils.js";
-const GENERIC_GLOBAL_CONFIG_PATH = join(homedir(), ".config", "mcp", "mcp.json");
-const AGENTS_GLOBAL_CONFIG_PATHS = [
-  join(homedir(), ".agents", "mcp.json"),
-  join(homedir(), ".agents", "mcp", "mcp.json")
-];
-const PROJECT_CONFIG_NAME = ".mcp.json";
-const PROJECT_PI_CONFIG_NAME = "mcp.json";
-const REPOPROMPT_BINARY_CANDIDATES = [
-  join(homedir(), "RepoPrompt", "repoprompt_cli"),
-  "/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp"
-];
-export const KNOWN_SERVER_PRESETS = [
-  {
-    id: "deepwiki",
-    name: "DeepWiki",
-    summary: "Ask questions about public GitHub repositories.",
-    entry: { url: "https://mcp.deepwiki.com/mcp", protocolVersion: "auto" }
-  },
-  {
-    id: "context7",
-    name: "Context7",
-    summary: "Look up current library documentation and examples.",
-    entry: { url: "https://mcp.context7.com/mcp", protocolVersion: "auto" }
-  },
-  {
-    id: "parallel-search",
-    name: "Parallel Search",
-    summary: "Search the web and fetch pages without an API key.",
-    entry: {
-      url: "https://search.parallel.ai/mcp",
-      protocolVersion: "auto",
-      directTools: true
-    }
-  },
-  {
-    id: "notion",
-    name: "Notion",
-    summary: "Search and work with your Notion workspace.",
-    entry: { url: "https://mcp.notion.com/mcp", auth: "oauth", protocolVersion: "auto" }
-  },
-  {
-    id: "github",
-    name: "GitHub",
-    summary: "Work with GitHub through your Copilot account.",
-    entry: { url: "https://api.githubcopilot.com/mcp", auth: "oauth", protocolVersion: "auto" }
-  },
-  {
-    id: "chrome-devtools",
-    name: "Chrome DevTools",
-    summary: "Inspect and automate a local Chrome browser.",
-    entry: { command: "npx", args: ["-y", "chrome-devtools-mcp@1.6.0"] }
-  }
-];
-const IMPORT_PATHS = {
-  cursor: [join(homedir(), ".cursor", "mcp.json")],
-  "claude-code": [
-    join(homedir(), ".claude", "mcp.json"),
-    join(homedir(), ".claude.json"),
-    join(homedir(), ".claude", "claude_desktop_config.json")
-  ],
-  "claude-desktop": [join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")],
-  codex: [
-    join(homedir(), ".codex", "config.toml"),
-    join(homedir(), ".codex", "config.json")
-  ],
-  opencode: [
-    join(homedir(), ".config", "opencode", "opencode.json"),
-    "./opencode.json"
-  ],
-  windsurf: [join(homedir(), ".windsurf", "mcp.json")],
-  vscode: [".vscode/mcp.json"]
-};
-export function getPiGlobalConfigPath(overridePath) {
-  return overridePath ? resolve(overridePath) : getAgentPath("mcp.json");
-}
-export function getGenericGlobalConfigPath() {
-  return GENERIC_GLOBAL_CONFIG_PATH;
-}
-export function getProjectConfigPath(cwd = process.cwd()) {
-  return resolve(cwd, PROJECT_CONFIG_NAME);
-}
-export function getProjectPiConfigPath(cwd = process.cwd()) {
-  return resolve(cwd, getConfigDirName(), PROJECT_PI_CONFIG_NAME);
-}
-export function getSharedConfigPath(target, cwd = process.cwd()) {
-  return target === "project" ? getProjectConfigPath(cwd) : getGenericGlobalConfigPath();
-}
-export function getConfigDiscoveryPaths(overridePath, cwd = process.cwd()) {
-  return getConfigSources(overridePath, cwd).map((source) => ({
-    label: source.label,
-    path: source.readPath,
-    exists: existsSync(source.readPath)
-  }));
-}
-export function findAvailableImportConfigs(cwd = process.cwd()) {
-  if (isExclusiveConfigMode())
-    return [];
-  const discovered = [];
-  for (const importKind of Object.keys(IMPORT_PATHS)) {
-    const importPath = resolveImportPath(importKind, cwd);
-    if (importPath) {
-      discovered.push({ kind: importKind, path: importPath });
-    }
-  }
-  return discovered;
-}
-function getConfigSourceSummaries(sourceSpecs) {
-  return sourceSpecs.map((source) => {
-    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
-    return {
-      id: source.id,
-      label: source.label,
-      path: source.readPath,
-      exists: existsSync(source.readPath),
-      scope: source.scope,
-      kind: source.shared ? "shared" : "pi",
-      serverCount: loaded ? Object.keys(loaded.mcpServers).length : 0
-    };
-  });
-}
-export function getMcpStandardConfigSummary(overridePath, cwd = process.cwd()) {
-  const sources = getConfigSourceSummaries(getConfigSources(overridePath, cwd));
-  return {
-    sources,
-    hasSharedServers: sources.some((source) => source.kind === "shared" && source.serverCount > 0),
-    fingerprint: JSON.stringify({ sources: sources.map((source) => [source.id, source.exists, source.serverCount]) })
-  };
-}
-export function getMcpDiscoverySummary(overridePath, cwd = process.cwd(), options = {}) {
-  const sourceSpecs = getConfigSources(overridePath, cwd);
-  const sources = getConfigSourceSummaries(sourceSpecs);
-  const includeHostConfigs = options.includeHostConfigs !== false;
-  const importKinds = isExclusiveConfigMode() ? readValidatedConfig(getPiGlobalConfigPath(overridePath), "MCP exclusive config")?.imports ?? [] : Object.keys(IMPORT_PATHS);
-  const imports = includeHostConfigs ? importKinds.map((kind) => {
-    const imported = loadImportedConfig(kind, cwd, `Failed to inspect imported MCP config from ${kind}:`);
-    if (!imported)
-      return null;
-    return {
-      kind,
-      path: imported.path,
-      serverCount: Object.keys(extractServers(imported.value, kind)).length
-    };
-  }).filter((value) => value !== null) : [];
-  const hostConfigDiscovery = isExclusiveConfigMode() ? "off" : getConfiguredHostConfigDiscovery(overridePath, cwd);
-  const hostConfigs = imports.map((entry) => ({ ...entry, active: hostConfigDiscovery === "on" }));
-  const settings = getMergedSettings(overridePath, cwd);
-  const agentPlugins = isExclusiveConfigMode() ? [] : getAgentPluginSummaries(settings?.agentPluginPaths, cwd);
-  const totalServerCount = sources.reduce((sum, source) => sum + source.serverCount, 0) + agentPlugins.reduce((sum, plugin) => sum + plugin.serverCount, 0);
-  const hasSharedServers = sources.some((source) => source.kind === "shared" && source.serverCount > 0) || agentPlugins.some((plugin) => plugin.serverCount > 0);
-  const hasPiOwnedServers = sources.some((source) => source.kind === "pi" && source.serverCount > 0);
-  const hasAnyDetectedPaths = sources.some((source) => source.exists) || imports.length > 0 || agentPlugins.length > 0;
-  const hasAnyConfig = totalServerCount > 0 || imports.some((entry) => entry.serverCount > 0) || hasAnyDetectedPaths;
-  const summaryWithoutRepoPrompt = {
-    sources,
-    imports,
-    hostConfigs,
-    hostConfigDiscovery,
-    agentPlugins,
-    conflicts: getConfigConflicts(sourceSpecs, imports, cwd),
-    hasAnyConfig,
-    hasAnyDetectedPaths,
-    hasSharedServers,
-    hasPiOwnedServers,
-    totalServerCount
-  };
-  const fingerprint = JSON.stringify({
-    sources: sources.map((source) => [source.id, source.exists, source.serverCount]),
-    imports: imports.map((entry) => [entry.kind, entry.path, entry.serverCount]),
-    agentPlugins: agentPlugins.map((entry) => [entry.path, entry.name, entry.serverCount]),
-    hostConfigDiscovery,
-    conflicts: summaryWithoutRepoPrompt.conflicts
-  });
-  return {
-    ...summaryWithoutRepoPrompt,
-    fingerprint,
-    repoPrompt: detectRepoPrompt(summaryWithoutRepoPrompt, cwd)
-  };
-}
-export function cloneMcpConfig(config) {
-  const cloned = structuredClone(config);
-  for (const [name, source] of Object.entries(config.mcpServers)) {
-    const builtInClone = cloneBuiltInAgentPluginEntry(source);
-    if (builtInClone)
-      cloned.mcpServers[name] = builtInClone;
-  }
-  return cloned;
-}
-export function loadMcpConfig(overridePath, cwd = process.cwd()) {
-  const sourceSpecs = getConfigSources(overridePath, cwd);
-  const hostConfigDiscovery = getConfiguredHostConfigDiscovery(overridePath, cwd);
-  let config = !isExclusiveConfigMode() && hostConfigDiscovery === "on" ? loadDiscoveredHostConfigs(cwd) : { mcpServers: {} };
-  for (const source of sourceSpecs) {
-    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
-    if (!loaded)
-      continue;
-    config = mergeConfigs(config, expandImports(loaded, cwd));
-  }
-  if (isExclusiveConfigMode())
-    return resolveConfiguredClaudePluginMcp(config, cwd);
-  const packageConfig = loadPackageMcpConfigs(cwd);
-  const pluginConfig = loadAgentPluginConfigs(config.settings?.agentPluginPaths, cwd);
-  const packageServers = Object.fromEntries(Object.entries(packageConfig.mcpServers).filter(([name]) => !Object.hasOwn(pluginConfig.mcpServers, name)));
-  const higherPrecedenceConfig = mergeConfigs({ mcpServers: packageServers }, mergeConfigs(pluginConfig, config));
-  return mergeClaudePluginMcpDefaults(config.claudePlugins, higherPrecedenceConfig, cwd);
-}
-export function resolveConfiguredClaudePluginMcp(config, cwd = process.cwd()) {
-  return mergeClaudePluginMcpDefaults(config.claudePlugins, config, cwd);
-}
-export function discoverConfiguredClaudePluginSkills(config, cwd = process.cwd()) {
-  return loadClaudePluginBundles(config.claudePlugins, cwd, validateConfig, { mcp: false, skills: true }).skillPaths;
-}
-function mergeClaudePluginMcpDefaults(plugins, higherPrecedenceConfig, cwd) {
-  const pluginServers = loadClaudePluginBundles(plugins, cwd, validateConfig, { mcp: true, skills: false }).mcpServers;
-  const higherNamesByNamespace = new Map(Object.keys(higherPrecedenceConfig.mcpServers).map((name) => [formatServerNamespace(name), name]));
-  const defaults = Object.fromEntries(Object.entries(pluginServers).filter(([name]) => {
-    const higherName = higherNamesByNamespace.get(formatServerNamespace(name));
-    if (!higherName || higherName === name)
-      return true;
-    console.warn(`Claude plugin MCP server "${name}" is shadowed by higher-precedence server "${higherName}" because both normalize to the same namespace`);
-    return false;
-  }));
-  return applySettingDefaults(mergeConfigs({ mcpServers: defaults }, higherPrecedenceConfig));
-}
-function applySettingDefaults(config) {
-  const exposeResources = config.settings?.exposeResources;
-  if (exposeResources === undefined)
-    return config;
-  const mcpServers = Object.fromEntries(Object.entries(config.mcpServers).map(([name, entry]) => [name, entry.exposeResources === undefined ? { ...entry, exposeResources } : entry]));
-  return { ...config, mcpServers };
-}
-function getMergedSettings(overridePath, cwd = process.cwd()) {
-  let settings;
-  for (const source of getConfigSources(overridePath, cwd)) {
-    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
-    if (loaded?.settings)
-      settings = { ...settings, ...loaded.settings };
-  }
-  return settings;
-}
-function getConfiguredHostConfigDiscovery(overridePath, cwd = process.cwd()) {
-  let configured = "off";
-  const settings = getMergedSettings(overridePath, cwd);
-  const value = settings?.hostConfigDiscovery;
-  if (value === "off" || value === "prompt" || value === "on")
-    configured = value;
-  return configured;
-}
-function loadDiscoveredHostConfigs(cwd) {
-  let config = { mcpServers: {} };
-  for (const importKind of Object.keys(IMPORT_PATHS)) {
-    const imported = loadImportedConfig(importKind, cwd, `Failed to discover imported MCP config from ${importKind}:`);
-    if (!imported)
-      continue;
-    config = mergeConfigs(config, {
-      mcpServers: extractServers(imported.value, importKind)
-    });
-  }
-  return config;
-}
-function getConfigConflicts(sourceSpecs, imports, cwd) {
-  const seen = new Map;
-  const record = (name, source) => {
-    const entries = seen.get(name) ?? [];
-    if (!entries.some((entry) => entry.kind === source.kind && entry.path === source.path))
-      entries.push(source);
-    seen.set(name, entries);
-  };
-  for (const entry of imports) {
-    const imported = loadImportedConfig(entry.kind, cwd, `Failed to inspect imported MCP config from ${entry.kind}:`);
-    if (!imported)
-      continue;
-    for (const name of Object.keys(extractServers(imported.value, entry.kind))) {
-      record(name, { kind: "host", path: imported.path });
-    }
-  }
-  for (const source of sourceSpecs) {
-    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
-    if (!loaded)
-      continue;
-    if (loaded.imports?.length) {
-      for (const importKind of loaded.imports) {
-        const imported = loadImportedConfig(importKind, cwd, `Failed to inspect imported MCP config from ${importKind}:`);
-        if (!imported)
-          continue;
-        for (const name of Object.keys(extractServers(imported.value, importKind))) {
-          record(name, { kind: "host", path: imported.path });
-        }
-      }
-    }
-    for (const name of Object.keys(loaded.mcpServers)) {
-      record(name, {
-        kind: source.shared ? "shared" : "pi",
-        path: source.readPath
-      });
-    }
-  }
-  return [...seen.entries()].filter(([, sources]) => sources.length > 1).map(([serverName, sources]) => ({ serverName, sources, winner: sources[sources.length - 1] })).sort((left, right) => left.serverName.localeCompare(right.serverName));
-}
-function getConfigSources(overridePath, cwd = process.cwd()) {
-  const userPath = getPiGlobalConfigPath(overridePath);
-  const projectPath = getProjectConfigPath(cwd);
-  const projectPiPath = getProjectPiConfigPath(cwd);
-  const sources = [];
-  if (isExclusiveConfigMode()) {
-    return [{
-      id: "pi-global",
-      label: "DM exclusive config",
-      readPath: userPath,
-      writePath: userPath,
-      kind: "user",
-      shared: false,
-      scope: "global"
-    }];
-  }
-  if (GENERIC_GLOBAL_CONFIG_PATH !== userPath) {
-    sources.push({
-      id: "shared-global",
-      label: "user-global standard MCP",
-      readPath: GENERIC_GLOBAL_CONFIG_PATH,
-      writePath: userPath,
-      kind: "import",
-      importKind: "global MCP config",
-      shared: true,
-      scope: "global"
-    });
-  }
-  for (const [index, agentsPath] of AGENTS_GLOBAL_CONFIG_PATHS.entries()) {
-    if (agentsPath === userPath || agentsPath === GENERIC_GLOBAL_CONFIG_PATH)
-      continue;
-    sources.push({
-      id: index === 0 ? "agents-global" : "agents-nested-global",
-      label: index === 0 ? "user-global .agents MCP" : "user-global .agents nested MCP",
-      readPath: agentsPath,
-      writePath: userPath,
-      kind: "import",
-      importKind: index === 0 ? ".agents MCP config" : ".agents/mcp MCP config",
-      shared: true,
-      scope: "global"
-    });
-  }
-  sources.push({
-    id: "pi-global",
-    label: "DM global override",
-    readPath: userPath,
-    writePath: userPath,
-    kind: "user",
-    shared: false,
-    scope: "global"
-  });
-  const reservedPaths = new Set([
-    ...sources.map((source) => getConfigPathIdentity(source.readPath)),
-    getConfigPathIdentity(projectPath),
-    getConfigPathIdentity(projectPiPath)
-  ]);
-  const ancestorSources = new Map;
-  const descriptors = [
-    { id: "shared-project-ancestor", label: "ancestor standard MCP", path: getProjectConfigPath, shared: true },
-    { id: "pi-project-ancestor", label: "ancestor DM override", path: getProjectPiConfigPath, shared: false }
-  ];
-  const ancestorRoot = getConfiguredAncestorRoot(sources, cwd);
-  if (ancestorRoot) {
-    for (const dir of getAncestorProjectDirs(cwd, ancestorRoot)) {
-      for (const descriptor of descriptors) {
-        const path = descriptor.path(dir);
-        const identity = getConfigPathIdentity(path);
-        if (reservedPaths.has(identity) || !existsSync(path))
-          continue;
-        ancestorSources.delete(identity);
-        ancestorSources.set(identity, {
-          id: descriptor.id,
-          label: descriptor.label,
-          readPath: path,
-          writePath: path,
-          kind: "project",
-          shared: descriptor.shared,
-          scope: "project"
-        });
-      }
-    }
-  }
-  sources.push(...ancestorSources.values());
-  if (projectPath !== userPath) {
-    sources.push({
-      id: "shared-project",
-      label: "project standard MCP",
-      readPath: projectPath,
-      writePath: projectPath,
-      kind: "project",
-      shared: true,
-      scope: "project"
-    });
-  }
-  if (projectPiPath !== userPath && projectPiPath !== projectPath) {
-    sources.push({
-      id: "pi-project",
-      label: "project DM override",
-      readPath: projectPiPath,
-      writePath: projectPiPath,
-      kind: "project",
-      shared: false,
-      scope: "project"
-    });
-  }
-  return sources;
-}
-function getConfigPathIdentity(path) {
-  try {
-    return realpathSync(path);
-  } catch {
-    return resolve(path);
-  }
-}
-function isWithin(base, target) {
-  const path = relative(base, target);
-  return path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
-}
-function getConfiguredAncestorRoot(globalSources, cwd) {
-  let configured;
-  for (const source of globalSources) {
-    const roots = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`)?.settings?.ancestorConfigRoots;
-    if (roots !== undefined)
-      configured = roots;
-  }
-  if (configured === undefined || Array.isArray(configured) && configured.length === 0)
-    return;
-  if (!Array.isArray(configured)) {
-    console.warn("Invalid settings.ancestorConfigRoots: expected an array of paths");
-    return;
-  }
-  const home = getConfigPathIdentity(resolve(homedir()));
-  const canonicalCwd = getConfigPathIdentity(resolve(cwd));
-  const valid = [];
-  for (const entry of configured) {
-    const expanded = typeof entry === "string" && entry.startsWith("~/") ? join(homedir(), entry.slice(2)) : entry;
-    if (typeof expanded !== "string" || !isAbsolute(expanded)) {
-      console.warn(`Invalid settings.ancestorConfigRoots entry ${JSON.stringify(entry)}: expected an absolute path or ~/...`);
-      continue;
-    }
-    try {
-      const root = realpathSync(expanded);
-      if (!statSync(root).isDirectory() || !isWithin(home, root) || !isWithin(root, canonicalCwd))
-        throw new Error;
-      valid.push(root);
-    } catch {
-      console.warn(`Invalid settings.ancestorConfigRoots entry ${JSON.stringify(entry)}: expected an existing directory under HOME containing cwd`);
-    }
-  }
-  return valid.sort((left, right) => right.length - left.length)[0];
-}
-function getAncestorProjectDirs(cwd, root) {
-  const start = getConfigPathIdentity(resolve(cwd));
-  const dirs = [];
-  let current = dirname(start);
-  while (isWithin(root, current)) {
-    dirs.unshift(current);
-    if (current === root)
-      break;
-    const parent = dirname(current);
-    if (parent === current)
-      break;
-    current = parent;
-  }
-  return dirs;
-}
-function isExclusiveConfigMode() {
-  return (process.env.DM_MCP_CONFIG_MODE ?? process.env.PI_MCP_CONFIG_MODE)?.trim().toLowerCase() === "exclusive";
-}
-function mergeConfigs(base, next) {
-  const imports = mergeImports(base.imports, next.imports);
-  const settings = next.settings ? { ...base.settings, ...next.settings } : base.settings;
-  const claudePlugins = next.claudePlugins ?? base.claudePlugins;
-  return {
-    mcpServers: mergeServerMaps(base.mcpServers, next.mcpServers),
-    ...imports !== undefined ? { imports } : {},
-    ...settings !== undefined ? { settings } : {},
-    ...claudePlugins !== undefined ? { claudePlugins } : {}
-  };
-}
-const URL_BOUND_AUTH_FIELDS = ["headers", "bearerToken", "bearerTokenEnv", "bearerTokenStore", "requestHeadersCommand", "caFile"];
-function mergeServerMaps(base, next) {
-  const merged = { ...base };
-  for (const [name, definition] of Object.entries(next)) {
-    const existing = merged[name];
-    let baseEntry = existing ?? {};
-    if (existing && typeof definition.command === "string") {
-      baseEntry = { ...existing };
-      for (const field of [
-        "url",
-        "headers",
-        "requestHeadersCommand",
-        "caFile",
-        "auth",
-        "bearerToken",
-        "bearerTokenEnv",
-        "bearerTokenStore",
-        "oauth",
-        "httpTransport",
-        "socket"
-      ]) {
-        delete baseEntry[field];
-      }
-    } else if (existing && typeof definition.url === "string") {
-      baseEntry = { ...existing };
-      for (const field of [
-        "command",
-        "args",
-        "env",
-        "cwd",
-        "pluginDataDir",
-        "literalEnv",
-        "inheritEnv",
-        "socket"
-      ]) {
-        delete baseEntry[field];
-      }
-    } else if (existing && typeof definition.socket === "string") {
-      baseEntry = { ...existing };
-      for (const field of [
-        "command",
-        "args",
-        "env",
-        "cwd",
-        "pluginDataDir",
-        "literalEnv",
-        "inheritEnv",
-        "url",
-        "headers",
-        "requestHeadersCommand",
-        "caFile",
-        "auth",
-        "bearerToken",
-        "bearerTokenEnv",
-        "bearerTokenStore",
-        "oauth",
-        "httpTransport"
-      ]) {
-        delete baseEntry[field];
-      }
-    }
-    if (existing && typeof definition.url === "string" && definition.url !== existing.url) {
-      if (baseEntry === existing)
-        baseEntry = { ...existing };
-      for (const field of URL_BOUND_AUTH_FIELDS) {
-        delete baseEntry[field];
-      }
-      if (baseEntry.oauth !== false) {
-        delete baseEntry.oauth;
-      }
-    }
-    if (existing && Object.hasOwn(definition, "env") && isBuiltInAgentPlugin(existing, "env") && !Object.hasOwn(definition, "literalEnv")) {
-      if (baseEntry === existing)
-        baseEntry = { ...existing };
-      delete baseEntry.literalEnv;
-    }
-    merged[name] = mergeBuiltInAgentPluginEntries(baseEntry, definition);
-  }
-  return merged;
-}
-function mergeImports(left, right) {
-  const merged = [...left ?? [], ...right ?? []];
-  if (merged.length === 0)
-    return;
-  return [...new Set(merged)];
-}
-function expandImports(config, cwd = process.cwd()) {
-  if (!config.imports?.length)
-    return config;
-  const importedServers = {};
-  for (const importKind of config.imports) {
-    const imported = loadImportedConfig(importKind, cwd, `Failed to import MCP config from ${importKind}:`);
-    if (!imported)
-      continue;
-    const servers = extractServers(imported.value, importKind);
-    for (const [name, definition] of Object.entries(servers)) {
-      if (!importedServers[name]) {
-        importedServers[name] = definition;
-      }
-    }
-  }
-  return {
-    imports: config.imports,
-    ...config.settings !== undefined ? { settings: config.settings } : {},
-    ...config.claudePlugins !== undefined ? { claudePlugins: config.claudePlugins } : {},
-    mcpServers: mergeServerMaps(importedServers, config.mcpServers)
-  };
-}
-function resolveImportCandidates(importKind, cwd) {
-  return (IMPORT_PATHS[importKind] ?? []).map((candidate) => {
-    if (importKind === "opencode" && candidate === "./opencode.json") {
-      const start = resolve(cwd);
-      let gitRoot;
-      let current = start;
-      while (true) {
-        if (existsSync(join(current, ".git"))) {
-          gitRoot = current;
-          break;
-        }
-        const parent = dirname(current);
-        if (parent === current)
-          break;
-        current = parent;
-      }
-      if (!gitRoot)
-        return join(start, "opencode.json");
-      current = start;
-      while (true) {
-        const projectConfig = join(current, "opencode.json");
-        if (existsSync(projectConfig) || current === gitRoot)
-          return projectConfig;
-        current = dirname(current);
-      }
-    }
-    return candidate.startsWith(".") ? resolve(cwd, candidate) : candidate;
-  });
-}
-function readImportedConfig(path) {
-  const raw = readFileSync(path, "utf-8");
-  return path.endsWith(".toml") ? parseToml(raw) : parseJsonWithComments(raw);
-}
-function loadImportedConfig(importKind, cwd, warningPrefix) {
-  if (importKind === "opencode") {
-    let merged = {};
-    let highestPrecedencePath;
-    for (const path of resolveImportCandidates(importKind, cwd)) {
-      if (!existsSync(path))
-        continue;
-      try {
-        const value = readImportedConfig(path);
-        if (value && typeof value === "object" && !Array.isArray(value)) {
-          const imported = value;
-          const mcp = isRecord(imported.mcp) ? imported.mcp : {};
-          const entries = isRecord(mcp.servers) ? { ...Object.fromEntries(Object.entries(mcp).filter(([name]) => name !== "servers" && name !== "timeout")), ...mcp.servers } : mcp;
-          const normalized = Object.fromEntries(Object.entries(entries).map(([name, entry]) => {
-            if (!isRecord(entry) || !isRecord(entry.oauth))
-              return [name, entry];
-            const { client_id, client_secret, auth_server_metadata_url, ...oauth } = entry.oauth;
-            return [name, {
-              ...entry,
-              oauth: {
-                ...oauth,
-                ...client_id !== undefined ? { clientId: client_id } : {},
-                ...client_secret !== undefined ? { clientSecret: client_secret } : {},
-                ...auth_server_metadata_url !== undefined ? { authServerMetadataUrl: auth_server_metadata_url } : {}
-              }
-            }];
-          }));
-          merged = mergeOpenCodeConfigs(merged, { ...imported, mcp: normalized });
-          highestPrecedencePath = path;
-        }
-      } catch (error) {
-        console.warn(warningPrefix, error);
-      }
-    }
-    return highestPrecedencePath ? { path: highestPrecedencePath, value: merged } : null;
-  }
-  for (const path of resolveImportCandidates(importKind, cwd)) {
-    if (!existsSync(path))
-      continue;
-    try {
-      return { path, value: readImportedConfig(path) };
-    } catch (error) {
-      console.warn(warningPrefix, error);
-    }
-  }
-  return null;
-}
-function resolveImportPath(importKind, cwd = process.cwd()) {
-  return loadImportedConfig(importKind, cwd, `Failed to discover imported MCP config from ${importKind}:`)?.path ?? null;
-}
-function readValidatedConfig(path, label) {
-  if (!existsSync(path))
-    return null;
-  try {
-    const text = readFileSync(path, "utf-8");
-    if (stripJsonComments(text, { trailingCommas: true }).trim() === "")
-      return null;
-    return validateConfig(parseJsonWithComments(text));
-  } catch (error) {
-    console.warn(`Failed to load ${label}:`, error);
-    return null;
-  }
-}
-function validateConfig(raw) {
-  if (!isRecord(raw)) {
-    return { mcpServers: {} };
-  }
-  return {
-    mcpServers: toServerEntries(raw.mcpServers ?? raw["mcp-servers"]),
-    ...Array.isArray(raw.imports) ? { imports: raw.imports } : {},
-    ...raw.settings !== undefined ? { settings: parseSettings(raw.settings) } : {},
-    ...raw.claudePlugins !== undefined ? { claudePlugins: parseClaudePlugins(raw.claudePlugins) } : {}
-  };
-}
-function parseSettings(value) {
-  if (!isRecord(value))
-    throw new Error("settings must be an object");
-  const settings = { ...value };
-  if (value.jev !== undefined) {
-    validateJevSettings(value.jev);
-    settings.jev = value.jev;
-  }
-  return settings;
-}
-function parseClaudePlugins(value) {
-  if (!Array.isArray(value)) {
-    console.warn("Invalid claudePlugins config: expected an array");
-    return [];
-  }
-  const plugins = [];
-  for (const [index, entry] of value.entries()) {
-    if (!isRecord(entry) || typeof entry.path !== "string" || entry.path.trim().length === 0) {
-      console.warn(`Invalid claudePlugins[${index}]: expected an object with a non-empty path`);
-      continue;
-    }
-    if (entry.mcp !== undefined && typeof entry.mcp !== "boolean" || entry.skills !== undefined && typeof entry.skills !== "boolean") {
-      console.warn(`Invalid claudePlugins[${index}] for ${entry.path}: mcp and skills must be booleans`);
-      continue;
-    }
-    if (entry.mcp !== true && entry.skills !== true) {
-      console.warn(`Invalid claudePlugins[${index}] for ${entry.path}: enable mcp, skills, or both`);
-      continue;
-    }
-    plugins.push({
-      path: entry.path,
-      ...entry.mcp !== undefined ? { mcp: entry.mcp } : {},
-      ...entry.skills !== undefined ? { skills: entry.skills } : {}
-    });
-  }
-  return plugins;
-}
-function toServerEntries(servers) {
-  if (!isRecord(servers))
-    return {};
-  const entries = {};
-  for (const [name, entry] of Object.entries(servers)) {
-    if (isServerEntry(entry))
-      entries[name] = entry;
-  }
-  return entries;
-}
-function isServerEntry(value) {
-  return isRecord(value);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function mergeOpenCodeConfigs(base, next) {
-  const baseMcp = base.mcp;
-  const nextMcp = next.mcp;
-  const mergedMcp = {
-    ...baseMcp && typeof baseMcp === "object" && !Array.isArray(baseMcp) ? baseMcp : {}
-  };
-  if (nextMcp && typeof nextMcp === "object" && !Array.isArray(nextMcp)) {
-    for (const [name, nextEntry] of Object.entries(nextMcp)) {
-      const baseEntry = mergedMcp[name];
-      if (baseEntry && typeof baseEntry === "object" && !Array.isArray(baseEntry) && nextEntry && typeof nextEntry === "object" && !Array.isArray(nextEntry)) {
-        const safeBase = { ...baseEntry };
-        const override = nextEntry;
-        if (typeof override.type === "string" && override.type !== safeBase.type) {
-          for (const field of ["command", "environment", "cwd", "url", "headers", "oauth"])
-            delete safeBase[field];
-        }
-        if (typeof override.url === "string" && override.url !== safeBase.url) {
-          delete safeBase.headers;
-          delete safeBase.oauth;
-        }
-        if (Array.isArray(override.command)) {
-          const baseCommand = safeBase.command;
-          const commandChanged = !Array.isArray(baseCommand) || override.command.length !== baseCommand.length || override.command.some((value, index) => value !== baseCommand[index]);
-          if (commandChanged) {
-            delete safeBase.environment;
-            delete safeBase.cwd;
-          }
-        }
-        const mergedEntry = { ...safeBase, ...override };
-        for (const field of ["environment", "headers", "oauth"]) {
-          const baseField = safeBase[field];
-          const nextField = override[field];
-          if (baseField && typeof baseField === "object" && !Array.isArray(baseField) && nextField && typeof nextField === "object" && !Array.isArray(nextField)) {
-            mergedEntry[field] = { ...baseField, ...nextField };
-          }
-        }
-        mergedMcp[name] = mergedEntry;
-      } else {
-        mergedMcp[name] = nextEntry;
-      }
-    }
-  }
-  return { ...base, ...next, mcp: mergedMcp };
-}
-function extractServers(config, kind) {
-  if (!config || typeof config !== "object")
-    return {};
-  const obj = config;
-  let servers;
-  switch (kind) {
-    case "claude-desktop":
-    case "claude-code":
-      servers = obj.mcpServers;
-      break;
-    case "codex":
-      servers = obj.mcp_servers ?? obj.mcpServers;
-      break;
-    case "cursor":
-    case "windsurf":
-    case "vscode":
-      servers = obj.mcpServers ?? obj["mcp-servers"];
-      break;
-    case "opencode":
-      servers = obj.mcp;
-      break;
-    default:
-      return {};
-  }
-  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
-    return {};
-  }
-  const mappedServers = {};
-  for (const [name, entry] of Object.entries(servers)) {
-    if (kind === "opencode") {
-      if (!entry || typeof entry !== "object" || Array.isArray(entry))
-        continue;
-      const raw = entry;
-      if (raw.enabled === false || raw.disabled === true)
-        continue;
-      if (raw.type === "local" && Array.isArray(raw.command) && raw.command.length > 0 && raw.command.every((value) => typeof value === "string")) {
-        const env = toStringRecord(raw.environment);
-        const command = raw.command[0];
-        if (command === undefined)
-          continue;
-        const mapped = {
-          command,
-          args: raw.command.slice(1),
-          ...env ? { env } : {},
-          ...typeof raw.cwd === "string" ? { cwd: raw.cwd } : {}
-        };
-        mappedServers[name] = mapped;
-        continue;
-      }
-      if (raw.type === "remote" && typeof raw.url === "string") {
-        const headers = toStringRecord(raw.headers);
-        const mapped = {
-          url: raw.url,
-          ...headers ? { headers } : {}
-        };
-        if (raw.oauth === false) {
-          mapped.oauth = false;
-        } else if (raw.oauth && typeof raw.oauth === "object" && !Array.isArray(raw.oauth)) {
-          const oauth = raw.oauth;
-          mapped.auth = "oauth";
-          const clientId = oauth.clientId;
-          const clientSecret = oauth.clientSecret;
-          const authServerMetadataUrl = oauth.authServerMetadataUrl;
-          mapped.oauth = {
-            ...typeof clientId === "string" ? { clientId } : {},
-            ...typeof clientSecret === "string" ? { clientSecret } : {},
-            ...typeof oauth.clientMetadataUrl === "string" ? { clientMetadataUrl: oauth.clientMetadataUrl } : {},
-            ...typeof oauth.scope === "string" ? { scope: oauth.scope } : {},
-            ...typeof authServerMetadataUrl === "string" ? { authServerMetadataUrl } : {},
-            ...typeof oauth.skipIssuerMetadataValidation === "boolean" ? { skipIssuerMetadataValidation: oauth.skipIssuerMetadataValidation } : {}
-          };
-        }
-        mappedServers[name] = mapped;
-      }
-      continue;
-    }
-    if (!isRecord(entry))
-      continue;
-    if (kind !== "codex") {
-      mappedServers[name] = entry;
-      continue;
-    }
-    const mapped = { ...entry };
-    const bearerTokenEnv = mapped.bearer_token_env_var;
-    const httpHeaders = mapped.http_headers;
-    const envHttpHeaders = mapped.env_http_headers;
-    if (typeof bearerTokenEnv === "string") {
-      mapped.bearerTokenEnv = bearerTokenEnv;
-      if (mapped.auth === undefined)
-        mapped.auth = "bearer";
-    }
-    if (httpHeaders && typeof httpHeaders === "object" && !Array.isArray(httpHeaders)) {
-      mapped.headers = { ...mapped.headers, ...httpHeaders };
-    }
-    if (envHttpHeaders && typeof envHttpHeaders === "object" && !Array.isArray(envHttpHeaders)) {
-      const headers = { ...mapped.headers };
-      for (const [header, envVar] of Object.entries(envHttpHeaders)) {
-        if (typeof envVar === "string" && headers[header] === undefined)
-          headers[header] = `$env:${envVar}`;
-      }
-      mapped.headers = headers;
-    }
-    delete mapped.bearer_token_env_var;
-    delete mapped.http_headers;
-    delete mapped.env_http_headers;
-    mappedServers[name] = mapped;
-  }
-  return mappedServers;
-}
-function serializeRawConfig(raw) {
-  return `${JSON.stringify(raw, null, 2)}
-`;
-}
-function buildUnifiedDiff(beforeText, afterText) {
-  if (beforeText === afterText)
-    return "(no changes)";
-  const before = beforeText.split(`
-`);
-  const after = afterText.split(`
-`);
-  const rows = before.length;
-  const cols = after.length;
-  const lcs = Array.from({ length: rows + 1 }, () => Array(cols + 1).fill(0));
-  for (let i = rows - 1;i >= 0; i--) {
-    for (let j = cols - 1;j >= 0; j--) {
-      const row = lcs[i];
-      const nextRow = lcs[i + 1];
-      if (!row || !nextRow)
-        continue;
-      row[j] = before[i] === after[j] ? (nextRow[j + 1] ?? 0) + 1 : Math.max(nextRow[j] ?? 0, row[j + 1] ?? 0);
-    }
-  }
-  const lines = ["--- before", "+++ after"];
-  let i = 0;
-  let j = 0;
-  while (i < rows || j < cols) {
-    if (i < rows && j < cols && before[i] === after[j]) {
-      lines.push(`  ${before[i]}`);
-      i++;
-      j++;
-      continue;
-    }
-    if (j < cols && (i === rows || (lcs[i]?.[j + 1] ?? 0) >= (lcs[i + 1]?.[j] ?? 0))) {
-      lines.push(`+ ${after[j]}`);
-      j++;
-      continue;
-    }
-    if (i < rows) {
-      lines.push(`- ${before[i]}`);
-      i++;
-    }
-  }
-  return lines.join(`
-`);
-}
-function buildConfigWritePreview(filePath, nextRaw) {
-  const existed = existsSync(filePath);
-  const beforeRaw = readRawConfigObject(filePath);
-  const beforeText = existed ? serializeRawConfig(beforeRaw) : "";
-  const afterText = serializeRawConfig(nextRaw);
-  return {
-    path: filePath,
-    existed,
-    changed: beforeText !== afterText,
-    beforeText,
-    afterText,
-    diffText: buildUnifiedDiff(beforeText, afterText)
-  };
-}
-function readRawConfigObject(filePath) {
-  if (!existsSync(filePath))
-    return {};
-  try {
-    const raw = parseJsonWithComments(readFileSync(filePath, "utf-8"));
-    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
-  } catch {
-    return {};
-  }
-}
-function writeConfigText(writePath, text) {
-  let mode;
-  try {
-    writePath = realpathSync(writePath);
-    mode = statSync(writePath).mode & 511;
-  } catch {}
-  mkdirSync(dirname(writePath), { recursive: true });
-  const tmpPath = `${writePath}.${process.pid}.tmp`;
-  rmSync(tmpPath, { force: true });
-  try {
-    writeFileSync(tmpPath, text, mode === undefined ? "utf-8" : { encoding: "utf-8", mode });
-    if (mode !== undefined)
-      chmodSync(tmpPath, mode);
-    renameSync(tmpPath, writePath);
-  } catch (error) {
-    try {
-      rmSync(tmpPath, { force: true });
-    } catch {}
-    throw error;
-  }
-}
-function writeRawConfigObject(filePath, raw) {
-  writeConfigText(filePath, `${JSON.stringify(raw, null, 2)}
-`);
-}
-export function writeSharedConfigText(filePath, text) {
-  if (!isRecord(parseJsonWithComments(text)))
-    throw new Error("top-level value must be an object");
-  writeConfigText(filePath, text);
-}
-export function writeJevSemanticSearchConfig(overridePath, cwd, allowedServers, effectiveJev) {
-  const filePath = overridePath ? getPiGlobalConfigPath(overridePath) : getProjectPiConfigPath(cwd);
-  let raw = {};
-  if (existsSync(filePath)) {
-    try {
-      const parsed = parseJsonWithComments(readFileSync(filePath, "utf8"));
-      if (!isRecord(parsed))
-        throw new Error("top-level value must be an object");
-      raw = parsed;
-    } catch (error) {
-      throw new Error(`Failed to update Jev settings at ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-  }
-  if (raw.settings !== undefined && !isRecord(raw.settings)) {
-    throw new Error(`Failed to update Jev settings at ${filePath}: settings must be an object`);
-  }
-  const settings = raw.settings;
-  const currentJev = settings?.jev;
-  if (currentJev !== undefined && currentJev !== false && !isRecord(currentJev)) {
-    throw new Error(`Failed to update Jev settings at ${filePath}: settings.jev must be an object or false`);
-  }
-  const jev = isRecord(effectiveJev) ? effectiveJev : isRecord(currentJev) ? currentJev : {};
-  const nextServers = [...new Set(allowedServers)].sort((a, b) => a.localeCompare(b));
-  const nextJev = { ...jev, semanticSearch: true, allowedServers: nextServers };
-  validateJevSettings(nextJev);
-  if (isRecord(currentJev) && JSON.stringify(currentJev) === JSON.stringify(nextJev))
-    return { path: filePath, changed: false };
-  raw.settings = { ...settings, jev: nextJev };
-  writeRawConfigObject(filePath, raw);
-  return { path: filePath, changed: true };
-}
-function getServersObject(raw) {
-  const existing = raw.mcpServers ?? raw["mcp-servers"] ?? {};
-  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-    return {};
-  }
-  return existing;
-}
-function setServersObject(raw, servers) {
-  delete raw["mcp-servers"];
-  raw.mcpServers = servers;
-}
-export function writeProjectServerDisabledOverride(overridePath, cwd, serverName, disabled) {
-  const filePath = getProjectPiConfigPath(cwd);
-  let raw = {};
-  if (existsSync(filePath)) {
-    try {
-      const parsed = parseJsonWithComments(readFileSync(filePath, "utf-8"));
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error("root value must be an object");
-      }
-      raw = parsed;
-    } catch (error) {
-      throw new Error(`Failed to read project MCP override at ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-  }
-  const serverKey = raw.mcpServers !== undefined ? "mcpServers" : raw["mcp-servers"] !== undefined ? "mcp-servers" : "mcpServers";
-  const rawServers = raw[serverKey];
-  if (rawServers !== undefined && (!rawServers || typeof rawServers !== "object" || Array.isArray(rawServers))) {
-    throw new Error(`Failed to update project MCP override at ${filePath}: ${serverKey} must be an object`);
-  }
-  const servers = rawServers ?? {};
-  const previous = servers[serverName];
-  if (previous !== undefined && (!previous || typeof previous !== "object" || Array.isArray(previous))) {
-    throw new Error(`Failed to update project MCP override at ${filePath}: server "${serverName}" must be an object`);
-  }
-  const existing = previous;
-  let next;
-  if (disabled) {
-    next = { ...existing, disabled: true };
-  } else {
-    next = Object.fromEntries(Object.entries(existing ?? {}).filter(([key]) => key !== "disabled"));
-    let lowerConfig = { mcpServers: {} };
-    for (const source of getConfigSources(overridePath, cwd)) {
-      if (source.readPath === filePath)
-        continue;
-      const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
-      if (loaded)
-        lowerConfig = mergeConfigs(lowerConfig, expandImports(loaded, cwd));
-    }
-    if (raw.imports !== undefined) {
-      if (!Array.isArray(raw.imports) || raw.imports.some((kind) => typeof kind !== "string" || !Object.hasOwn(IMPORT_PATHS, kind))) {
-        throw new Error(`Failed to update project MCP override at ${filePath}: imports contains an unsupported config kind`);
-      }
-      lowerConfig = mergeConfigs(lowerConfig, expandImports({ mcpServers: {}, imports: raw.imports }, cwd));
-    }
-    if (isServerDisabled(lowerConfig.mcpServers[serverName]))
-      next.disabled = false;
-  }
-  if (!existing && Object.keys(next).length === 0 || JSON.stringify(existing) === JSON.stringify(next)) {
-    return { path: filePath, changed: false };
-  }
-  if (Object.keys(next).length === 0)
-    delete servers[serverName];
-  else
-    servers[serverName] = next;
-  raw[serverKey] = servers;
-  writeRawConfigObject(filePath, raw);
-  return { path: filePath, changed: true };
-}
-function isRepoPromptServer(name, entry) {
-  const normalizedName = name.toLowerCase();
-  if (normalizedName.includes("repoprompt") || normalizedName === "rp") {
-    return true;
-  }
-  const command = entry.command?.toLowerCase() ?? "";
-  if (command.includes("repoprompt") || command.includes("rp-mcp") || command.endsWith("repoprompt_cli")) {
-    return true;
-  }
-  return (entry.args ?? []).some((arg) => typeof arg === "string" && arg.toLowerCase().includes("repoprompt"));
-}
-function findProjectRoot(cwd = process.cwd()) {
-  let current = resolve(cwd);
-  while (true) {
-    if (existsSync(join(current, ".git")) || existsSync(join(current, "package.json")) || existsSync(join(current, PROJECT_CONFIG_NAME)) || existsSync(join(current, ".dm"))) {
-      return current;
-    }
-    const parent = dirname(current);
-    if (parent === current)
-      return null;
-    current = parent;
-  }
-}
-function buildRepoPromptEntry(executablePath) {
-  return {
-    command: executablePath,
-    args: [],
-    lifecycle: "lazy"
-  };
-}
-function detectRepoPrompt(summary, cwd = process.cwd()) {
-  for (const source of summary.sources) {
-    if (source.kind !== "shared" || source.serverCount === 0)
-      continue;
-    const config = readValidatedConfig(source.path, `MCP config from ${source.path}`);
-    if (!config)
-      continue;
-    for (const [name, entry] of Object.entries(config.mcpServers)) {
-      if (isRepoPromptServer(name, entry)) {
-        return { configured: true, configuredPath: source.path };
-      }
-    }
-  }
-  const executablePath = REPOPROMPT_BINARY_CANDIDATES.find((candidate) => existsSync(candidate));
-  if (!executablePath) {
-    return { configured: false };
-  }
-  const projectRoot = findProjectRoot(cwd);
-  const targetPath = projectRoot ? join(projectRoot, PROJECT_CONFIG_NAME) : GENERIC_GLOBAL_CONFIG_PATH;
-  return {
-    configured: false,
-    executablePath,
-    targetPath,
-    serverName: "repoprompt",
-    entry: buildRepoPromptEntry(executablePath)
-  };
-}
-export function previewCompatibilityImports(importKinds, overridePath) {
-  const targetPath = getPiGlobalConfigPath(overridePath);
-  const raw = readRawConfigObject(targetPath);
-  const currentImports = Array.isArray(raw.imports) ? raw.imports.filter((value) => typeof value === "string") : [];
-  const merged = [...new Set([...currentImports, ...importKinds])];
-  const nextRaw = { ...raw, imports: merged };
-  setServersObject(nextRaw, getServersObject(nextRaw));
-  return buildConfigWritePreview(targetPath, nextRaw);
-}
-export function ensureCompatibilityImports(importKinds, overridePath) {
-  const targetPath = getPiGlobalConfigPath(overridePath);
-  const raw = readRawConfigObject(targetPath);
-  const currentImports = Array.isArray(raw.imports) ? raw.imports.filter((value) => typeof value === "string") : [];
-  const merged = [...new Set([...currentImports, ...importKinds])];
-  const added = merged.filter((kind) => !currentImports.includes(kind));
-  if (added.length === 0) {
-    return { path: targetPath, added: [] };
-  }
-  raw.imports = merged;
-  const servers = getServersObject(raw);
-  setServersObject(raw, servers);
-  writeRawConfigObject(targetPath, raw);
-  return { path: targetPath, added };
-}
-export function buildStarterProjectConfig() {
-  return {
-    mcpServers: {}
-  };
-}
-export function previewStarterSharedConfig(target, cwd = process.cwd()) {
-  const targetPath = getSharedConfigPath(target, cwd);
-  const nextRaw = { mcpServers: buildStarterProjectConfig().mcpServers };
-  return buildConfigWritePreview(targetPath, nextRaw);
-}
-export function writeStarterSharedConfig(target, cwd = process.cwd()) {
-  const targetPath = getSharedConfigPath(target, cwd);
-  const raw = { mcpServers: buildStarterProjectConfig().mcpServers };
-  writeRawConfigObject(targetPath, raw);
-  return targetPath;
-}
-export function previewStarterProjectConfig(cwd = process.cwd()) {
-  return previewStarterSharedConfig("project", cwd);
-}
-export function writeStarterProjectConfig(cwd = process.cwd()) {
-  return writeStarterSharedConfig("project", cwd);
-}
-export function previewSharedServerEntry(filePath, serverName, entry) {
-  const raw = readRawConfigObject(filePath);
-  const nextRaw = { ...raw };
-  const servers = getServersObject(nextRaw);
-  servers[serverName] = entry;
-  setServersObject(nextRaw, servers);
-  return buildConfigWritePreview(filePath, nextRaw);
-}
-export function writeSharedServerEntry(filePath, serverName, entry) {
-  const raw = readRawConfigObject(filePath);
-  const servers = getServersObject(raw);
-  servers[serverName] = entry;
-  setServersObject(raw, servers);
-  writeRawConfigObject(filePath, raw);
-  return filePath;
-}
-export function getServerProvenance(overridePath, cwd = process.cwd()) {
-  const provenance = new Map;
-  const userPath = getPiGlobalConfigPath(overridePath);
-  if (getConfiguredHostConfigDiscovery(overridePath, cwd) === "on") {
-    for (const importKind of Object.keys(IMPORT_PATHS)) {
-      const imported = loadImportedConfig(importKind, cwd, `Failed to inspect imported MCP config from ${importKind}:`);
-      if (!imported)
-        continue;
-      for (const name of Object.keys(extractServers(imported.value, importKind))) {
-        provenance.set(name, { path: userPath, kind: "import", importKind });
-      }
-    }
-  }
-  for (const source of getConfigSources(overridePath, cwd)) {
-    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
-    if (!loaded)
-      continue;
-    if (loaded.imports?.length) {
-      for (const importKind of loaded.imports) {
-        const imported = loadImportedConfig(importKind, cwd, `Failed to inspect imported MCP config from ${importKind}:`);
-        if (!imported)
-          continue;
-        const servers = extractServers(imported.value, importKind);
-        for (const name of Object.keys(servers)) {
-          if (!provenance.has(name)) {
-            provenance.set(name, { path: userPath, kind: "import", importKind });
-          }
-        }
-      }
-    }
-    for (const name of Object.keys(loaded.mcpServers)) {
-      provenance.set(name, {
-        path: source.writePath,
-        kind: source.kind,
-        ...source.importKind !== undefined ? { importKind: source.importKind } : {}
-      });
-    }
-  }
-  return provenance;
-}
-export function writeDirectToolsConfig(changes, provenance, fullConfig) {
-  const byPath = new Map;
-  for (const [serverName, value] of changes) {
-    const prov = provenance.get(serverName);
-    if (!prov)
-      continue;
-    const targetPath = prov.path;
-    if (!byPath.has(targetPath))
-      byPath.set(targetPath, []);
-    byPath.get(targetPath).push({ name: serverName, value, prov });
-  }
-  for (const [filePath, entries] of byPath) {
-    const raw = readRawConfigObject(filePath);
-    const servers = getServersObject(raw);
-    for (const { name, value, prov } of entries) {
-      if (prov.kind === "import") {
-        const fullDef = fullConfig.mcpServers[name];
-        if (fullDef) {
-          servers[name] = { ...fullDef, directTools: value };
-        }
-      } else if (servers[name]) {
-        servers[name] = { ...servers[name], directTools: value };
-      }
-    }
-    setServersObject(raw, servers);
-    writeRawConfigObject(filePath, raw);
-  }
-}
-export function resolveConfiguredOAuthDir(raw, cwd = process.cwd()) {
-  if (raw === undefined || raw === null)
-    return;
-  if (typeof raw !== "string") {
-    throw new Error("settings.oauthDir must be a string");
-  }
-  const trimmed = raw.trim();
-  if (!trimmed)
-    return;
-  return resolve(cwd, trimmed);
-}