@kwonye/mcpx 0.1.91 → 0.1.94

package/dist/{cli-btx8jwra.js → cli-csfsg1yf.js}

@@ -3,7 +3,7 @@ import {
   getConfigPath,
   readJsonFile,
   writeJsonAtomic
-} from "./cli-zbbeadz8.js";
+} from "./cli-zjepj3sj.js";
 import {
   normalizeServerSpecEnabled
 } from "./cli-s4gspqdf.js";
@@ -317,6 +317,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 +332,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(),
@@ -350,6 +369,57 @@ var projectEntrySchema = z.object({
   path: z.string(),
   disabledServers: z.array(z.string()).default([])
 });
+var pluginComponentSchema = z.enum(["mcpServers", "skills", "hooks", "agents", "commands"]);
+var discoveredComponentSchema = z.object({
+  id: z.string(),
+  type: pluginComponentSchema,
+  path: z.string(),
+  description: z.string().optional()
+});
+var discoveredMcpServerSchema = z.object({
+  id: z.string(),
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  cwd: z.string().optional()
+});
+var discoveredComponentsSchema = z.object({
+  skills: z.array(discoveredComponentSchema).default([]),
+  commands: z.array(discoveredComponentSchema).default([]),
+  agents: z.array(discoveredComponentSchema).default([]),
+  hooks: z.array(discoveredComponentSchema).default([]),
+  mcpServers: z.array(discoveredMcpServerSchema).default([])
+});
+var managedPluginSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  source: z.string(),
+  version: z.string(),
+  ref: z.string(),
+  resolvedSha: z.string(),
+  installedAt: z.string(),
+  root: z.string(),
+  dataDir: z.string(),
+  components: z.record(pluginComponentSchema, z.boolean()).default({}),
+  discovered: discoveredComponentsSchema.default({}),
+  enabled: z.boolean().default(true),
+  status: z.enum(["healthy", "unhealthy", "preparing", "updating", "error"]).default("healthy"),
+  error: z.string().optional(),
+  serverNames: z.array(z.string()).default([]),
+  projectedClients: z.array(z.string()).default([]),
+  approvals: z.object({
+    mcpServers: z.boolean().optional(),
+    skills: z.boolean().optional(),
+    hooks: z.boolean().optional(),
+    agents: z.boolean().optional(),
+    commands: z.boolean().optional()
+  }).optional(),
+  projectOverrides: z.record(z.string(), z.object({
+    enabled: z.boolean().optional(),
+    components: z.record(pluginComponentSchema, z.boolean()).optional(),
+    config: z.record(z.string(), z.unknown()).optional()
+  })).optional()
+});
 var configSchema = z.object({
   schemaVersion: z.literal(1).default(1),
   gateway: z.object({
@@ -363,7 +433,8 @@ var configSchema = z.object({
   }),
   servers: z.record(z.string(), serverSchema).default({}),
   clients: z.record(z.string(), clientStateSchema).default({}),
-  projects: z.record(z.string(), projectEntrySchema).default({})
+  projects: z.record(z.string(), projectEntrySchema).default({}),
+  plugins: z.record(z.string(), managedPluginSchema).default({})
 });
 var projectConfigSchema = z.object({
   name: z.string().min(1).optional(),
@@ -379,14 +450,35 @@ function defaultConfig() {
     },
     servers: {},
     clients: {},
-    projects: {}
+    projects: {},
+    plugins: {}
   };
 }
 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)) {
@@ -400,14 +492,26 @@ function loadConfig(configPath = getConfigPath()) {
     gateway: parsed.data.gateway,
     servers,
     clients: clientEntries,
-    projects: parsed.data.projects
+    projects: parsed.data.projects,
+    plugins: parsed.data.plugins
   });
 }
 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) {
@@ -444,6 +548,30 @@ 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);
@@ -468,4 +596,4 @@ function resolveActiveConfig(options = {}) {
   };
 }
 
-export { tokenizeCommandLine, parseCliAddCommand, defaultConfig, loadConfig, saveConfig, loadProjectConfig, saveProjectConfig, loadMergedConfig, resolveActiveConfig };
+export { tokenizeCommandLine, parseCliAddCommand, ConfigLoadError, defaultConfig, loadConfig, saveConfig, loadProjectConfig, saveProjectConfig, loadMergedConfig, migrateProjectServers, resolveActiveConfig };