@kwonye/mcpx 0.1.104 → 0.1.106

package/dist/{chunk-wq4zd3t7.js → chunk-brxwa30j.js}

@@ -1,15 +1,17 @@
+import {
+  exports_external
+} from "./chunk-p7yzyt87.js";
 import {
   findProjectConfigPath,
   getConfigPath,
   readJsonFile,
   writeJsonAtomic
-} from "./chunk-cqenqnxk.js";
+} from "./chunk-grkz21sq.js";
 import {
   normalizeServerSpecEnabled
 } from "./chunk-bjw71y54.js";
 
 // src/core/config.ts
-import { z } from "zod";
 import path from "node:path";
 import fs from "node:fs";
 
@@ -321,7 +323,7 @@ function isHttpUrl2(value) {
   }
 }
 function isClientInternalCommand(command) {
-  return /\.app\/Contents\//.test(command);
+  return /\.app\/Contents\//.test(command) && !/mcpx(?:-dev)?\.app\/Contents\//.test(command);
 }
 function repairServerSpec(spec) {
   if (spec.transport !== "stdio") {
@@ -428,128 +430,140 @@ class ConfigLoadError extends Error {
     this.issues = issues;
   }
 }
-var clientStateSchema = z.object({
-  status: z.enum(["SYNCED", "UNSUPPORTED_HTTP", "ERROR", "SKIPPED"]),
-  lastSyncAt: z.string().optional(),
-  message: z.string().optional(),
-  configPath: z.string().optional()
+var clientStateSchema = exports_external.object({
+  status: exports_external.enum(["SYNCED", "UNSUPPORTED_HTTP", "ERROR", "SKIPPED"]),
+  lastSyncAt: exports_external.string().optional(),
+  message: exports_external.string().optional(),
+  configPath: exports_external.string().optional()
 });
-var httpServerSchema = z.object({
-  transport: z.literal("http"),
-  url: z.url(),
-  headers: z.record(z.string(), z.string()).optional(),
-  enabled: z.boolean().default(true)
+var httpServerSchema = exports_external.object({
+  scope: exports_external.string().optional(),
+  transport: exports_external.literal("http"),
+  url: exports_external.url(),
+  headers: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+  enabled: exports_external.boolean().default(true)
 });
-var stdioServerSchema = z.object({
-  transport: z.literal("stdio"),
-  command: z.string().min(1),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  cwd: z.string().min(1).optional(),
-  enabled: z.boolean().default(true)
+var stdioServerSchema = exports_external.object({
+  scope: exports_external.string().optional(),
+  transport: exports_external.literal("stdio"),
+  command: exports_external.string().min(1),
+  args: exports_external.array(exports_external.string()).optional(),
+  env: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+  cwd: exports_external.string().min(1).optional(),
+  enabled: exports_external.boolean().default(true)
 });
-var serverSchema = z.discriminatedUnion("transport", [httpServerSchema, stdioServerSchema]);
-var projectEntrySchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  disabledServers: z.array(z.string()).default([])
+var serverSchema = exports_external.discriminatedUnion("transport", [httpServerSchema, stdioServerSchema]);
+var projectEntrySchema = exports_external.object({
+  name: exports_external.string(),
+  path: exports_external.string(),
+  disabledServers: exports_external.array(exports_external.string()).default([])
 });
-var pluginComponentSchema = z.enum(["mcpServers", "skills", "hooks", "agents", "commands"]);
-var discoveredComponentSchema = z.object({
-  id: z.string(),
+var pluginComponentSchema = exports_external.enum(["mcpServers", "skills", "hooks", "agents", "commands"]);
+var discoveredComponentSchema = exports_external.object({
+  id: exports_external.string(),
   type: pluginComponentSchema,
-  path: z.string(),
-  description: z.string().optional()
+  path: exports_external.string(),
+  description: exports_external.string().optional()
 });
-var discoveredMcpServerSchema = z.object({
-  id: z.string(),
-  transport: z.enum(["stdio", "http"]).optional(),
-  command: z.string(),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  cwd: z.string().optional(),
-  url: z.string().optional(),
-  oauthResource: z.string().optional()
+var discoveredMcpServerSchema = exports_external.object({
+  id: exports_external.string(),
+  transport: exports_external.enum(["stdio", "http"]).optional(),
+  command: exports_external.string(),
+  args: exports_external.array(exports_external.string()).optional(),
+  env: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+  cwd: exports_external.string().optional(),
+  url: exports_external.string().optional(),
+  oauthResource: exports_external.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 discoveredComponentsSchema = exports_external.object({
+  skills: exports_external.array(discoveredComponentSchema).default([]),
+  commands: exports_external.array(discoveredComponentSchema).default([]),
+  agents: exports_external.array(discoveredComponentSchema).default([]),
+  hooks: exports_external.array(discoveredComponentSchema).default([]),
+  mcpServers: exports_external.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({}),
+var managedPluginSchema = exports_external.object({
+  id: exports_external.string(),
+  name: exports_external.string(),
+  source: exports_external.string(),
+  version: exports_external.string(),
+  ref: exports_external.string(),
+  resolvedSha: exports_external.string(),
+  installedAt: exports_external.string(),
+  root: exports_external.string(),
+  dataDir: exports_external.string(),
+  components: exports_external.record(pluginComponentSchema, exports_external.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()
+  enabled: exports_external.boolean().default(true),
+  status: exports_external.enum(["healthy", "unhealthy", "preparing", "updating", "error"]).default("healthy"),
+  error: exports_external.string().optional(),
+  serverNames: exports_external.array(exports_external.string()).default([]),
+  projectedClients: exports_external.array(exports_external.string()).default([]),
+  approvals: exports_external.object({
+    mcpServers: exports_external.boolean().optional(),
+    skills: exports_external.boolean().optional(),
+    hooks: exports_external.boolean().optional(),
+    agents: exports_external.boolean().optional(),
+    commands: exports_external.boolean().optional()
   }).optional(),
-  marketplace: z.object({
-    name: z.string(),
-    pluginName: z.string(),
-    sourceFingerprint: z.string()
+  marketplace: exports_external.object({
+    name: exports_external.string(),
+    pluginName: exports_external.string(),
+    sourceFingerprint: exports_external.string()
   }).optional(),
-  updateError: z.string().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()
+  updateError: exports_external.string().optional(),
+  pinned: exports_external.boolean().default(false),
+  previous: exports_external.object({ version: exports_external.string(), resolvedSha: exports_external.string(), root: exports_external.string() }).optional(),
+  projectOverrides: exports_external.record(exports_external.string(), exports_external.object({
+    enabled: exports_external.boolean().optional(),
+    components: exports_external.partialRecord(pluginComponentSchema, exports_external.boolean()).optional(),
+    config: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
   })).optional()
 });
-var managedMarketplaceSchema = z.object({
-  name: z.string(),
-  displayName: z.string(),
-  source: z.string(),
-  sourceType: z.enum(["github", "git", "local", "hosted-json"]).default("github"),
-  manifestPath: z.string().optional(),
-  format: z.enum(["claude", "codex"]).optional(),
-  builtIn: z.boolean().default(false),
-  autoUpdate: z.boolean().default(false),
-  addedAt: z.string(),
-  lastCheckedAt: z.string().optional(),
-  lastUpdatedAt: z.string().optional(),
-  resolvedRevision: z.string().optional(),
-  status: z.enum(["ready", "stale", "error", "unavailable"]).default("unavailable"),
-  error: z.string().optional()
+var managedMarketplaceSchema = exports_external.object({
+  name: exports_external.string(),
+  displayName: exports_external.string(),
+  source: exports_external.string(),
+  sourceType: exports_external.enum(["github", "git", "local", "hosted-json"]).default("github"),
+  manifestPath: exports_external.string().optional(),
+  format: exports_external.enum(["claude", "codex"]).optional(),
+  builtIn: exports_external.boolean().default(false),
+  autoUpdate: exports_external.boolean().default(false),
+  addedAt: exports_external.string(),
+  lastCheckedAt: exports_external.string().optional(),
+  lastUpdatedAt: exports_external.string().optional(),
+  resolvedRevision: exports_external.string().optional(),
+  status: exports_external.enum(["ready", "stale", "error", "unavailable"]).default("unavailable"),
+  error: exports_external.string().optional()
 });
-var configSchema = z.object({
-  schemaVersion: z.literal(1).default(1),
-  gateway: z.object({
-    port: z.number().int().min(1).max(65535).default(37373),
-    tokenRef: z.string().default("secret://local_gateway_token"),
-    autoStart: z.boolean().default(true)
+var configSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1).default(1),
+  consumers: exports_external.record(exports_external.string(), exports_external.object({ tokenRef: exports_external.string().regex(/^secret:\/\/[A-Za-z0-9._-]+$/), projectPath: exports_external.string().optional() })).default({}),
+  packages: exports_external.record(exports_external.string(), exports_external.object({ id: exports_external.string(), root: exports_external.string(), source: exports_external.string(), harness: exports_external.string(), fingerprint: exports_external.string(), pinned: exports_external.boolean(), name: exports_external.string().optional(), identity: exports_external.string().optional(), servers: exports_external.array(exports_external.string()).optional(), skills: exports_external.array(exports_external.object({ id: exports_external.string(), path: exports_external.string(), projectionPath: exports_external.string() })).optional(), scope: exports_external.string().optional(), previous: exports_external.object({ root: exports_external.string(), fingerprint: exports_external.string() }).optional() })).default({}),
+  revision: exports_external.number().int().nonnegative().default(0),
+  harnesses: exports_external.record(exports_external.string(), exports_external.object({ mode: exports_external.enum(["observe", "selected", "automatic"]) })).default({}),
+  origins: exports_external.record(exports_external.string(), exports_external.object({ id: exports_external.string(), kind: exports_external.string(), harness: exports_external.string(), source: exports_external.string(), nativeKey: exports_external.string(), fingerprint: exports_external.string(), operationId: exports_external.string() })).default({}),
+  gateway: exports_external.object({
+    port: exports_external.number().int().min(1).max(65535).default(37373),
+    tokenRef: exports_external.string().regex(/^secret:\/\/[A-Za-z0-9._-]+$/).default("secret://local_gateway_token"),
+    autoStart: exports_external.boolean().default(true)
   }).default({
     port: 37373,
     tokenRef: "secret://local_gateway_token",
     autoStart: true
   }),
-  servers: z.record(z.string(), serverSchema).default({}),
-  clients: z.record(z.string(), clientStateSchema).default({}),
-  projects: z.record(z.string(), projectEntrySchema).default({}),
-  plugins: z.record(z.string(), managedPluginSchema).default({}),
-  marketplaces: z.record(z.string(), managedMarketplaceSchema).default({})
+  servers: exports_external.record(exports_external.string(), serverSchema).default({}),
+  clients: exports_external.record(exports_external.string(), clientStateSchema).default({}),
+  projects: exports_external.record(exports_external.string(), projectEntrySchema).default({}),
+  plugins: exports_external.record(exports_external.string(), managedPluginSchema).default({}),
+  marketplaces: exports_external.record(exports_external.string(), managedMarketplaceSchema).default({}),
+  secrets: exports_external.object({
+    backend: exports_external.enum(["file", "keychain"]).default("file")
+  }).default({ backend: "file" })
 });
-var projectConfigSchema = z.object({
-  name: z.string().min(1).optional(),
-  servers: z.record(z.string(), serverSchema).default({})
+var projectConfigSchema = exports_external.object({
+  name: exports_external.string().min(1).optional(),
+  servers: exports_external.record(exports_external.string(), serverSchema).default({})
 });
 function defaultConfig() {
   return {
@@ -563,7 +577,8 @@ function defaultConfig() {
     clients: {},
     projects: {},
     plugins: {},
-    marketplaces: ensureDefaultMarketplaces(undefined)
+    marketplaces: ensureDefaultMarketplaces(undefined),
+    secrets: { backend: "file" }
   };
 }
 function loadConfig(configPath = getConfigPath()) {
@@ -594,19 +609,23 @@ function loadConfig(configPath = getConfigPath()) {
   }
   const clientEntries = {};
   for (const [key, value] of Object.entries(parsed.data.clients)) {
-    if (["claude", "claude-desktop", "codex", "cursor", "cline", "opencode", "kiro", "vscode", "qwen", "openclaw", "hermes"].includes(key)) {
-      clientEntries[key] = value;
-    }
+    clientEntries[key] = value;
   }
   const servers = Object.fromEntries(Object.entries(parsed.data.servers).map(([name, spec]) => [name, normalizeServerSpecEnabled(spec)]));
   return repairConfig({
     schemaVersion: 1,
+    consumers: parsed.data.consumers,
+    packages: parsed.data.packages,
+    revision: parsed.data.revision,
+    harnesses: parsed.data.harnesses,
+    origins: parsed.data.origins,
     gateway: parsed.data.gateway,
     servers,
     clients: clientEntries,
     projects: parsed.data.projects,
     plugins: parsed.data.plugins,
-    marketplaces: ensureDefaultMarketplaces(parsed.data.marketplaces)
+    marketplaces: ensureDefaultMarketplaces(parsed.data.marketplaces),
+    secrets: parsed.data.secrets
   });
 }
 function saveConfig(config, configPath = getConfigPath()) {
@@ -735,4 +754,4 @@ function resolveActiveConfig(options = {}) {
 
 export { tokenizeCommandLine, parseCliAddCommand, ConfigLoadError, defaultConfig, loadConfig, saveConfig, loadProjectConfig, saveProjectConfig, loadMergedConfig, migrateProjectServers, resolveActiveConfig };
 
-//# debugId=83D38E071988634664756E2164756E21
+//# debugId=E2636B557C478E8864756E2164756E21

package/dist/chunk-chaj8a8b.js

@@ -0,0 +1,45 @@
+import {
+  sha256
+} from "./chunk-grkz21sq.js";
+
+// src/core/file-state.ts
+import fs from "node:fs";
+import path from "node:path";
+function pathFingerprint(target) {
+  try {
+    const stat = fs.lstatSync(target);
+    if (stat.isSymbolicLink())
+      return sha256(`link:${fs.readlinkSync(target)}`);
+    if (stat.isDirectory())
+      return sha256(JSON.stringify(fs.readdirSync(target).sort().map((name) => [name, pathFingerprint(path.join(target, name))])));
+    return sha256(fs.readFileSync(target).toString("base64"));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+function processAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function lockOwnerAlive(lockPath) {
+  try {
+    const owner = Number(fs.readFileSync(lockPath, "utf8").trim());
+    if (!owner && Date.now() - fs.statSync(lockPath).mtimeMs < 2000)
+      return true;
+    return processAlive(owner);
+  } catch {
+    return false;
+  }
+}
+
+export { pathFingerprint, processAlive, lockOwnerAlive };
+
+//# debugId=95EF3C9852F8B9B864756E2164756E21

package/dist/chunk-e96643mj.js

@@ -0,0 +1,26 @@
+import {
+  STATUS_CLIENTS,
+  buildStatusReport
+} from "./chunk-nh6hhv29.js";
+import"./chunk-0xt563m1.js";
+import"./chunk-wvzap0na.js";
+import"./chunk-1mrkz29t.js";
+import"./chunk-4aafp444.js";
+import"./chunk-a2gen8bn.js";
+import"./chunk-wztmp5b4.js";
+import"./chunk-8v13hqrp.js";
+import"./chunk-t20f49g3.js";
+import"./chunk-hahs24dv.js";
+import"./chunk-chaj8a8b.js";
+import"./chunk-7rq88hb3.js";
+import"./chunk-brxwa30j.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-grkz21sq.js";
+import"./chunk-bjw71y54.js";
+import"./chunk-wj4tjacg.js";
+export {
+  STATUS_CLIENTS,
+  buildStatusReport
+};
+
+//# debugId=770606CBE047940064756E2164756E21

package/dist/{chunk-02r7k4ax.js → chunk-ew06e41w.js}

@@ -11,11 +11,17 @@ import {
   resolveMarketplacePluginSource,
   setMarketplaceAutoUpdate,
   updateMarketplaceInstalledPlugin
-} from "./chunk-s9v1epnk.js";
-import"./chunk-z1k63fa3.js";
-import"./chunk-wq4zd3t7.js";
-import"./chunk-cz8cdmw1.js";
-import"./chunk-cqenqnxk.js";
+} from "./chunk-1mrkz29t.js";
+import"./chunk-4aafp444.js";
+import"./chunk-wztmp5b4.js";
+import"./chunk-8v13hqrp.js";
+import"./chunk-t20f49g3.js";
+import"./chunk-hahs24dv.js";
+import"./chunk-chaj8a8b.js";
+import"./chunk-7rq88hb3.js";
+import"./chunk-brxwa30j.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-grkz21sq.js";
 import"./chunk-bjw71y54.js";
 import"./chunk-wj4tjacg.js";
 export {
@@ -33,4 +39,4 @@ export {
   updateMarketplaceInstalledPlugin
 };
 
-//# debugId=AB01773EEA66F21764756E2164756E21
+//# debugId=76A638EA438F529364756E2164756E21

package/dist/chunk-ezk8txcy.js

@@ -0,0 +1,23 @@
+import {
+  applyAuthReference,
+  defaultAuthSecretName,
+  listAuthBindings,
+  maybePrefixBearer,
+  removeAuthReference,
+  resolveAuthTarget,
+  secretRefName,
+  toSecretRef
+} from "./chunk-0xt563m1.js";
+import"./chunk-wj4tjacg.js";
+export {
+  applyAuthReference,
+  defaultAuthSecretName,
+  listAuthBindings,
+  maybePrefixBearer,
+  removeAuthReference,
+  resolveAuthTarget,
+  secretRefName,
+  toSecretRef
+};
+
+//# debugId=E513FBA6B876E2F964756E2164756E21

package/dist/{chunk-cqenqnxk.js → chunk-grkz21sq.js}

@@ -30,6 +30,12 @@ function getTelemetryPath() {
 function getSkillsDir() {
   return path.join(getConfigRoot(), "mcpx", "skills");
 }
+function getSkillPackagesRoot() {
+  return path.join(getDataRoot(), "mcpx", "skills", "packages");
+}
+function getSkillStatePath() {
+  return path.join(getDataRoot(), "mcpx", "skills", "state.json");
+}
 function getManagedIndexPath() {
   return path.join(getDataRoot(), "mcpx", "managed-index.json");
 }
@@ -125,13 +131,39 @@ function writeJsonAtomic(filePath, data) {
   const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   const content = `${JSON.stringify(data, null, 2)}
 `;
-  fs2.writeFileSync(tempPath, content, { mode: 384 });
+  const descriptor = fs2.openSync(tempPath, "w", 384);
+  try {
+    fs2.writeFileSync(descriptor, content);
+    fs2.fsyncSync(descriptor);
+  } finally {
+    fs2.closeSync(descriptor);
+  }
   fs2.renameSync(tempPath, filePath);
+  if (process.platform !== "win32") {
+    const directory = fs2.openSync(path2.dirname(filePath), "r");
+    try {
+      fs2.fsyncSync(directory);
+    } finally {
+      fs2.closeSync(directory);
+    }
+  }
 }
 function sha256(value) {
   return crypto2.createHash("sha256").update(value).digest("hex");
 }
+function readJsonStrict(filePath, fallback) {
+  if (!fs2.existsSync(filePath))
+    return fallback;
+  try {
+    const value = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw new Error("Expected an object");
+    return value;
+  } catch {
+    throw new Error(`Native configuration is invalid JSON: ${filePath}`);
+  }
+}
 
-export { homeDir, getConfigPath, getTelemetryPath, getSkillsDir, getManagedIndexPath, getSecretsStorePath, getSecretsKeyPath, getPidPath, getLogPath, getGatewayTokenPath, getUpdatesDir, getStagedVersionPath, getUpdateLockPath, getOAuthLockPath, getPluginCacheRoot, getPluginDataRoot, getMarketplaceCacheRoot, getMarketplaceUpdateStatePath, getMarketplaceUpdateLockPath, ensureDir, ensureParentDir, findProjectConfigPath, readJsonFile, writeJsonAtomic, sha256 };
+export { homeDir, getConfigRoot, getDataRoot, getStateRoot, getConfigPath, getTelemetryPath, getSkillsDir, getSkillPackagesRoot, getSkillStatePath, getManagedIndexPath, getSecretsStorePath, getSecretsKeyPath, getRuntimeDir, getPidPath, getLogPath, getGatewayTokenPath, getUpdatesDir, getStagedVersionPath, getUpdateLockPath, getOAuthLockPath, getPluginCacheRoot, getPluginDataRoot, getMarketplaceCacheRoot, getMarketplaceUpdateStatePath, getMarketplaceUpdateLockPath, ensureDir, ensureParentDir, findProjectConfigPath, readJsonFile, writeJsonAtomic, sha256, readJsonStrict };
 
-//# debugId=96DE5993BD5A6D3864756E2164756E21
+//# debugId=40EB4EBB6125E60564756E2164756E21

package/dist/{chunk-12vgqm89.js → chunk-gvjxpk98.js}

@@ -1,6 +1,6 @@
 import {
   require_src
-} from "./chunk-tnhekcpv.js";
+} from "./chunk-56z18csx.js";
 import {
   __commonJS,
   __require

package/dist/chunk-h9kp47rp.js

@@ -0,0 +1,18 @@
+import {
+  exportEnvironment,
+  importEnvironment
+} from "./chunk-qf8bj9y7.js";
+import"./chunk-hahs24dv.js";
+import"./chunk-chaj8a8b.js";
+import"./chunk-7rq88hb3.js";
+import"./chunk-brxwa30j.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-grkz21sq.js";
+import"./chunk-bjw71y54.js";
+import"./chunk-wj4tjacg.js";
+export {
+  exportEnvironment,
+  importEnvironment
+};
+
+//# debugId=6F722CF50728EEF764756E2164756E21

package/dist/chunk-hahs24dv.js

@@ -0,0 +1,127 @@
+import {
+  lockOwnerAlive
+} from "./chunk-chaj8a8b.js";
+import {
+  loadConfig,
+  loadProjectConfig,
+  saveConfig,
+  saveProjectConfig
+} from "./chunk-brxwa30j.js";
+import {
+  findProjectConfigPath,
+  getConfigPath
+} from "./chunk-grkz21sq.js";
+
+// src/core/config-store.ts
+import fs from "node:fs";
+import path from "node:path";
+var LOCK_RETRY_MS = 50;
+var LOCK_MAX_RETRIES = 40;
+var inProcessQueues = new Map;
+function getLockPath(filePath) {
+  return `${filePath}.lock`;
+}
+function acquireLock(filePath) {
+  const lockPath = getLockPath(filePath);
+  try {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const fd = fs.openSync(lockPath, "wx");
+    fs.writeSync(fd, String(process.pid));
+    fs.closeSync(fd);
+    return true;
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return false;
+    }
+    try {
+      if (!lockOwnerAlive(lockPath)) {
+        fs.unlinkSync(lockPath);
+        return acquireLock(filePath);
+      }
+    } catch {
+      return acquireLock(filePath);
+    }
+    return false;
+  }
+}
+function releaseLock(filePath) {
+  try {
+    fs.unlinkSync(getLockPath(filePath));
+  } catch {}
+}
+function mutateFile(filePath, load, save, fn) {
+  const prevQueue = inProcessQueues.get(filePath) ?? Promise.resolve();
+  const nextQueue = prevQueue.then(() => executeWithLock(filePath, load, save, fn), () => executeWithLock(filePath, load, save, fn));
+  inProcessQueues.set(filePath, nextQueue.catch(() => {
+    return;
+  }));
+  return nextQueue;
+}
+async function executeWithLock(filePath, load, save, fn) {
+  let acquired = false;
+  for (let attempt = 0;attempt < LOCK_MAX_RETRIES; attempt++) {
+    acquired = acquireLock(filePath);
+    if (acquired)
+      break;
+    await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+  }
+  if (!acquired) {
+    throw new Error(`Could not acquire lock for ${filePath}.`);
+  }
+  try {
+    const data = load(filePath);
+    const result = await fn(data);
+    save(data, filePath);
+    return result;
+  } finally {
+    releaseLock(filePath);
+  }
+}
+function mutateConfig(fn, configPath) {
+  return mutateFile(configPath ?? getConfigPath(), loadConfig, saveConfig, async (config) => {
+    const result = await fn(config);
+    config.revision = (config.revision ?? 0) + 1;
+    return result;
+  });
+}
+function mutateProjectConfig(projectConfigPath, fn) {
+  return mutateFile(projectConfigPath, (p) => loadProjectConfig(p), saveProjectConfig, fn);
+}
+async function mutateActiveConfig(options, mutator) {
+  const globalPath = getConfigPath();
+  if (!options.global) {
+    const projectConfigPath = findProjectConfigPath();
+    if (options.local) {
+      const projectPath = projectConfigPath ? path.dirname(projectConfigPath) : process.cwd();
+      const localPath = path.join(projectPath, ".mcpx.json");
+      const globalConfig = loadConfig(globalPath);
+      const result2 = await mutateProjectConfig(localPath, async (projectConfig) => {
+        const mergedConfig = {
+          ...globalConfig,
+          servers: { ...globalConfig.servers, ...projectConfig.servers }
+        };
+        const mutatorResult = await mutator(mergedConfig, { type: "project", projectPath });
+        const localServers = {};
+        for (const [name, spec] of Object.entries(mergedConfig.servers)) {
+          if (!(name in globalConfig.servers)) {
+            localServers[name] = spec;
+          }
+        }
+        projectConfig.servers = localServers;
+        return mutatorResult;
+      });
+      return { type: "project", configPath: localPath, projectPath, result: result2 };
+    }
+    if (projectConfigPath) {
+      const projectPath = path.dirname(projectConfigPath);
+      const result2 = await mutateConfig((config) => mutator(config, { type: "project", projectPath }), globalPath);
+      return { type: "project", configPath: globalPath, projectPath, result: result2 };
+    }
+  }
+  const result = await mutateConfig((config) => mutator(config, { type: "global" }), globalPath);
+  return { type: "global", configPath: globalPath, result };
+}
+
+export { mutateConfig, mutateProjectConfig, mutateActiveConfig };
+
+//# debugId=F410213A0C687F0164756E2164756E21