@kwonye/mcpx 0.1.93 → 0.1.95

package/dist/{cli-np0wwh6m.js → cli-v27bt25d.js}

@@ -94,6 +94,12 @@ function parseCliAddCommand(command) {
   if (parts[0] === "code" && parts[1] === "--add-mcp") {
     return parseVSCodeAdd(parts[2]);
   }
+  if (parts[0] === "openclaw" && parts[1] === "mcp" && parts[2] === "add") {
+    return parseOpenClawAdd(parts.slice(3));
+  }
+  if (parts[0] === "hermes" && parts[1] === "mcp" && parts[2] === "add") {
+    return parseHermesAdd(parts.slice(3));
+  }
   if (parts[0] === "add") {
     return parseStandardAdd(parts.slice(1));
   }
@@ -211,6 +217,48 @@ function parseVSCodeAdd(jsonPayload) {
   }
   throw new Error("JSON payload must include 'url' or 'command'");
 }
+function parseOpenClawAdd(args) {
+  const header = [];
+  const env = [];
+  let cwd;
+  const values = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--header") {
+      header.push(args[++i]);
+    } else if (arg === "--env") {
+      env.push(args[++i]);
+    } else if (arg === "--cwd" || arg === "--workingDirectory") {
+      cwd = args[++i];
+    } else if (arg === "--arg") {
+      values.push(args[++i]);
+    } else if (arg === "--transport" || arg === "--auth" || arg === "--scope") {
+      i++;
+    } else {
+      values.push(arg);
+    }
+  }
+  return buildServerSpec(values, { header, env, cwd });
+}
+function parseHermesAdd(args) {
+  const env = [];
+  const values = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--env") {
+      env.push(args[++i]);
+    } else if (arg === "--args") {
+      while (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        values.push(args[++i]);
+      }
+    } else if (arg === "--auth") {
+      i++;
+    } else {
+      values.push(arg);
+    }
+  }
+  return buildServerSpec(values, { header: [], env });
+}
 function buildServerSpec(values, options) {
   if (values.length < 2) {
     throw new Error("Usage: add [--transport auto|http|stdio] <name> <url|command> [args...]");
@@ -317,6 +365,14 @@ function repairConfig(config) {
       servers[name] = repaired;
     }
   }
+  const existingNames = new Set(Object.keys(servers));
+  if (config.projects) {
+    for (const project of Object.values(config.projects)) {
+      if (project.disabledServers) {
+        project.disabledServers = project.disabledServers.filter((s) => existingNames.has(s));
+      }
+    }
+  }
   return {
     ...config,
     servers
@@ -324,6 +380,17 @@ function repairConfig(config) {
 }
 
 // src/core/config.ts
+class ConfigLoadError extends Error {
+  configPath;
+  backupPath;
+  issues;
+  constructor(configPath, message, issues) {
+    super(message);
+    this.name = "ConfigLoadError";
+    this.configPath = configPath;
+    this.issues = issues;
+  }
+}
 var clientStateSchema = z.object({
   status: z.enum(["SYNCED", "UNSUPPORTED_HTTP", "ERROR", "SKIPPED"]),
   lastSyncAt: z.string().optional(),
@@ -436,14 +503,34 @@ function defaultConfig() {
   };
 }
 function loadConfig(configPath = getConfigPath()) {
-  const raw = readJsonFile(configPath, defaultConfig());
+  if (!fs.existsSync(configPath)) {
+    return defaultConfig();
+  }
+  let raw;
+  try {
+    const content = fs.readFileSync(configPath, "utf8");
+    raw = JSON.parse(content);
+  } catch (err) {
+    const backupPath = `${configPath}.invalid-${Date.now()}`;
+    try {
+      fs.copyFileSync(configPath, backupPath);
+    } catch {}
+    const message = `Failed to parse config file at ${configPath}.`;
+    throw new ConfigLoadError(configPath, `${message} Backed up to ${backupPath}.`, [`JSON parse error: ${err.message}`]);
+  }
   const parsed = configSchema.safeParse(raw);
   if (!parsed.success) {
-    return defaultConfig();
+    const backupPath = `${configPath}.invalid-${Date.now()}`;
+    try {
+      fs.copyFileSync(configPath, backupPath);
+    } catch {}
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`);
+    const message = `Config file at ${configPath} has validation errors.`;
+    throw new ConfigLoadError(configPath, `${message} Backed up to ${backupPath}.`, issues);
   }
   const clientEntries = {};
   for (const [key, value] of Object.entries(parsed.data.clients)) {
-    if (["claude", "claude-desktop", "codex", "cursor", "cline", "opencode", "kiro", "vscode", "qwen"].includes(key)) {
+    if (["claude", "claude-desktop", "codex", "cursor", "cline", "opencode", "kiro", "vscode", "qwen", "openclaw", "hermes"].includes(key)) {
       clientEntries[key] = value;
     }
   }
@@ -461,7 +548,18 @@ function saveConfig(config, configPath = getConfigPath()) {
   config.servers = Object.fromEntries(Object.entries(config.servers).map(([name, spec]) => [name, normalizeServerSpecEnabled(spec)]));
   writeJsonAtomic(configPath, config);
 }
-function loadProjectConfig(projectConfigPath) {
+function loadProjectConfig(projectConfigPath, options) {
+  if (options?.strict) {
+    const raw2 = readJsonFile(projectConfigPath, null);
+    if (raw2 === null) {
+      return { servers: {} };
+    }
+    const parsed2 = projectConfigSchema.safeParse(raw2);
+    if (!parsed2.success) {
+      throw new ConfigLoadError(projectConfigPath, `Project config at ${projectConfigPath} has validation errors.`, parsed2.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`));
+    }
+    return parsed2.data;
+  }
   const raw = readJsonFile(projectConfigPath, { servers: {} });
   const parsed = projectConfigSchema.safeParse(raw);
   if (!parsed.success) {
@@ -498,28 +596,76 @@ function loadMergedConfig(configPath = getConfigPath()) {
   }
   return config;
 }
+function migrateProjectServers(config, projectPath) {
+  const localConfigPath = path.join(projectPath, ".mcpx.json");
+  if (!fs.existsSync(localConfigPath)) {
+    return { migrated: [], conflicts: [] };
+  }
+  const migrated = [];
+  const conflicts = [];
+  try {
+    const localConfig = loadProjectConfig(localConfigPath);
+    for (const [serverName, spec] of Object.entries(localConfig.servers)) {
+      if (config.servers[serverName]) {
+        conflicts.push(serverName);
+        continue;
+      }
+      const normalized = normalizeServerSpecEnabled(spec);
+      if (normalized.transport === "stdio" && !normalized.cwd) {
+        normalized.cwd = projectPath;
+      }
+      config.servers[serverName] = normalized;
+      migrated.push(serverName);
+    }
+  } catch {}
+  return { migrated, conflicts };
+}
 function resolveActiveConfig(options = {}) {
   const globalPath = getConfigPath();
-  const config = loadConfig(globalPath);
+  const globalConfig = loadConfig(globalPath);
   if (!options.global) {
     const projectConfigPath = findProjectConfigPath();
-    if (options.local || projectConfigPath) {
+    if (options.local) {
       const projectPath = projectConfigPath ? path.dirname(projectConfigPath) : process.cwd();
+      const localPath = path.join(projectPath, ".mcpx.json");
+      const projectConfig = loadProjectConfig(localPath);
+      const mergedConfig = {
+        ...globalConfig,
+        servers: { ...globalConfig.servers, ...projectConfig.servers }
+      };
+      return {
+        type: "project",
+        configPath: localPath,
+        projectPath,
+        config: mergedConfig,
+        save: () => {
+          const localServers = {};
+          for (const [name, spec] of Object.entries(mergedConfig.servers)) {
+            if (!(name in globalConfig.servers)) {
+              localServers[name] = spec;
+            }
+          }
+          saveProjectConfig({ ...projectConfig, servers: localServers }, localPath);
+        }
+      };
+    }
+    if (projectConfigPath) {
+      const projectPath = path.dirname(projectConfigPath);
       return {
         type: "project",
         configPath: globalPath,
         projectPath,
-        config,
-        save: () => saveConfig(config, globalPath)
+        config: globalConfig,
+        save: () => saveConfig(globalConfig, globalPath)
       };
     }
   }
   return {
     type: "global",
     configPath: globalPath,
-    config,
-    save: () => saveConfig(config, globalPath)
+    config: globalConfig,
+    save: () => saveConfig(globalConfig, globalPath)
   };
 }
 
-export { tokenizeCommandLine, parseCliAddCommand, defaultConfig, loadConfig, saveConfig, loadProjectConfig, saveProjectConfig, loadMergedConfig, resolveActiveConfig };
+export { tokenizeCommandLine, parseCliAddCommand, ConfigLoadError, defaultConfig, loadConfig, saveConfig, loadProjectConfig, saveProjectConfig, loadMergedConfig, migrateProjectServers, resolveActiveConfig };