@kwonye/mcpx 0.1.87 → 0.1.88

package/dist/{cli-t81mwnff.js → cli-vwnh1mqg.js}

@@ -2,11 +2,11 @@ import {
   loadConfig,
   loadMergedConfig,
   saveConfig
-} from "./cli-bq7zsrv6.js";
+} from "./cli-btx8jwra.js";
 import {
   SecretsManager,
   ensureGatewayToken
-} from "./cli-dvj5waat.js";
+} from "./cli-qfvawh8e.js";
 import {
   ensureDir,
   ensureParentDir,
@@ -290,6 +290,7 @@ function mapRegistryToSpec(_name, option, resolvedValues) {
 }
 
 // src/adapters/claude.ts
+import fs2 from "node:fs";
 import path2 from "node:path";
 import { z } from "zod";
 
@@ -352,6 +353,9 @@ function errorResult(clientId, configPath, message) {
     message
   };
 }
+function managedGatewayEntryName(serverName) {
+  return `${serverName} (mcpx)`;
+}
 function isManagedGatewayProjection(entryName) {
   return entryName.endsWith(" (mcpx)");
 }
@@ -419,6 +423,22 @@ function syncMcpExcludedArray(raw, managedNames, managedEntries) {
 }
 
 // src/adapters/claude.ts
+function normalizeProjectKey(p) {
+  try {
+    return fs2.realpathSync(path2.resolve(p));
+  } catch {
+    return path2.resolve(p);
+  }
+}
+function syncProjectDisabledArray(project, managedNames, disabledForThisProject) {
+  const existingNonManaged = (project.disabledMcpServers ?? []).filter((name) => !managedNames.includes(name));
+  const combined = [...existingNonManaged, ...disabledForThisProject];
+  if (combined.length > 0) {
+    project.disabledMcpServers = combined;
+  } else {
+    delete project.disabledMcpServers;
+  }
+}
 var stringMapSchema = z.record(z.string(), z.string());
 var claudeEntrySchema = z.object({
   type: z.string().optional(),
@@ -531,12 +551,26 @@ class ClaudeAdapter {
       }
       raw.mcpServers = topLevelServers;
       syncDisabledMcpServersArray(raw, managedNames, options.managedEntries);
+      const scopeByNormalizedPath = new Map;
+      for (const scope of options.projectScopes ?? []) {
+        scopeByNormalizedPath.set(normalizeProjectKey(scope.path), scope.disabledServerNames);
+      }
       const projects = raw.projects ?? {};
       for (const projectPath of Object.keys(projects)) {
         const project = projects[projectPath] ?? {};
-        syncDisabledMcpServersArray(project, managedNames, options.managedEntries);
+        const disabledForThis = scopeByNormalizedPath.get(normalizeProjectKey(projectPath)) ?? [];
+        syncProjectDisabledArray(project, managedNames, disabledForThis);
         projects[projectPath] = project;
       }
+      for (const scope of options.projectScopes ?? []) {
+        if (scope.disabledServerNames.length === 0)
+          continue;
+        const normalizedKey = normalizeProjectKey(scope.path);
+        const alreadyExists = Object.keys(projects).some((p) => normalizeProjectKey(p) === normalizedKey);
+        if (!alreadyExists) {
+          projects[scope.path] = { disabledMcpServers: [...scope.disabledServerNames] };
+        }
+      }
       raw.projects = projects;
       writeJsonAtomic(configPath, raw);
       setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(Object.entries(serverEntries).map(([name, entry]) => [name, JSON.stringify(entry)])));
@@ -680,7 +714,7 @@ class ClaudeDesktopAdapter {
 
 // src/adapters/codex.ts
 import path4 from "node:path";
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import { parse, stringify } from "@iarna/toml";
 import { z as z3 } from "zod";
 var stringMapSchema3 = z3.preprocess((value) => {
@@ -711,10 +745,10 @@ class CodexAdapter {
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
     const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs2.existsSync(configPath)) {
+    if (!configPath || !fs3.existsSync(configPath)) {
       return result;
     }
-    const existing = fs2.readFileSync(configPath, "utf8");
+    const existing = fs3.readFileSync(configPath, "utf8");
     const doc = existing.trim().length > 0 ? parse(existing) : {};
     const mcpServers = doc.mcp_servers ?? {};
     for (const [name, rawEntry] of Object.entries(mcpServers)) {
@@ -769,7 +803,7 @@ class CodexAdapter {
       return errorResult(this.id, undefined, "Unable to resolve Codex config.toml path.");
     }
     try {
-      const existing = fs2.existsSync(configPath) ? fs2.readFileSync(configPath, "utf8") : "";
+      const existing = fs3.existsSync(configPath) ? fs3.readFileSync(configPath, "utf8") : "";
       const doc = existing.trim().length > 0 ? parse(existing) : {};
       const mcpServers = doc.mcp_servers ?? {};
       removeSourceEntries(mcpServers, options.sourceEntriesToRemove);
@@ -790,10 +824,10 @@ class CodexAdapter {
         mcpServers[name] = entry;
       }
       doc.mcp_servers = mcpServers;
-      fs2.mkdirSync(path4.dirname(configPath), { recursive: true });
+      fs3.mkdirSync(path4.dirname(configPath), { recursive: true });
       const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
-      fs2.writeFileSync(tmpPath, stringify(doc), { mode: 384 });
-      fs2.renameSync(tmpPath, configPath);
+      fs3.writeFileSync(tmpPath, stringify(doc), { mode: 384 });
+      fs3.renameSync(tmpPath, configPath);
       setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(Object.entries(serverEntries).map(([name, entry]) => [name, JSON.stringify(entry)])));
       return okResult(this.id, configPath);
     } catch (error) {
@@ -933,7 +967,7 @@ class CursorAdapter {
 
 // src/adapters/cline.ts
 import path6 from "node:path";
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import { z as z5 } from "zod";
 var stringMapSchema5 = z5.record(z5.string(), z5.string());
 var clineEntrySchema = z5.object({
@@ -970,7 +1004,7 @@ class ClineAdapter {
   detectConfigPath() {
     const candidates = getCandidatePaths();
     for (const candidate of candidates) {
-      if (fs3.existsSync(candidate)) {
+      if (fs4.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -982,7 +1016,7 @@ class ClineAdapter {
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
     const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs3.existsSync(configPath)) {
+    if (!configPath || !fs4.existsSync(configPath)) {
       return result;
     }
     const raw = readJsonFile(configPath, {});
@@ -1040,7 +1074,7 @@ class ClineAdapter {
     if (!configPath) {
       return errorResult(this.id, undefined, "Unable to resolve Cline MCP config path.");
     }
-    if (!fs3.existsSync(configPath)) {
+    if (!fs4.existsSync(configPath)) {
       return okResult(this.id, configPath, "Cline config not found; skipping sync.");
     }
     try {
@@ -1080,7 +1114,7 @@ class ClineAdapter {
 }
 
 // src/adapters/kiro.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import path7 from "node:path";
 import { z as z6 } from "zod";
 var stringMapSchema6 = z6.record(z6.string(), z6.string());
@@ -1198,22 +1232,22 @@ class KiroAdapter {
   }
   syncSkills(skills) {
     const skillsDir = path7.join(homeDir(), ".kiro", "skills");
-    if (!fs4.existsSync(skillsDir)) {
-      fs4.mkdirSync(skillsDir, { recursive: true });
+    if (!fs5.existsSync(skillsDir)) {
+      fs5.mkdirSync(skillsDir, { recursive: true });
     }
-    const existingFiles = fs4.readdirSync(skillsDir);
+    const existingFiles = fs5.readdirSync(skillsDir);
     const managedIds = new Set(skills.map((s) => s.id));
     for (const file of existingFiles) {
       if (file.endsWith(".md")) {
         const id = path7.basename(file, ".md");
         if (!managedIds.has(id)) {
-          fs4.unlinkSync(path7.join(skillsDir, file));
+          fs5.unlinkSync(path7.join(skillsDir, file));
         }
       }
     }
     for (const skill of skills) {
       const targetPath = path7.join(skillsDir, `${skill.id}.md`);
-      fs4.writeFileSync(targetPath, skill.content, "utf-8");
+      fs5.writeFileSync(targetPath, skill.content, "utf-8");
     }
   }
 }
@@ -1468,7 +1502,7 @@ class VsCodeAdapter {
 }
 
 // src/adapters/qwen.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import path10 from "node:path";
 import { z as z9 } from "zod";
 var stringMapSchema9 = z9.record(z9.string(), z9.string());
@@ -1583,22 +1617,22 @@ class QwenAdapter {
   }
   syncSkills(skills) {
     const skillsDir = path10.join(homeDir(), ".qwen", "skills");
-    if (!fs5.existsSync(skillsDir)) {
-      fs5.mkdirSync(skillsDir, { recursive: true });
+    if (!fs6.existsSync(skillsDir)) {
+      fs6.mkdirSync(skillsDir, { recursive: true });
     }
-    const existingFiles = fs5.readdirSync(skillsDir);
+    const existingFiles = fs6.readdirSync(skillsDir);
     const managedIds = new Set(skills.map((s) => s.id));
     for (const file of existingFiles) {
       if (file.endsWith(".md")) {
         const id = path10.basename(file, ".md");
         if (!managedIds.has(id)) {
-          fs5.unlinkSync(path10.join(skillsDir, file));
+          fs6.unlinkSync(path10.join(skillsDir, file));
         }
       }
     }
     for (const skill of skills) {
       const targetPath = path10.join(skillsDir, `${skill.id}.md`);
-      fs5.writeFileSync(targetPath, skill.content, "utf-8");
+      fs6.writeFileSync(targetPath, skill.content, "utf-8");
     }
   }
 }
@@ -1643,6 +1677,13 @@ function saveManagedIndex(index, filePath = getManagedIndexPath()) {
 function getGatewayUrl(config) {
   return `http://127.0.0.1:${config.gateway.port}/mcp`;
 }
+function buildProjectScopes(config) {
+  const globallyEnabled = new Set(Object.entries(config.servers).filter(([, spec]) => isServerEnabled(spec)).map(([name]) => name));
+  return Object.values(config.projects ?? {}).map((project) => {
+    const disabledServerNames = (project.disabledServers ?? []).filter((name) => globallyEnabled.has(name)).map((name) => managedGatewayEntryName(name));
+    return { path: project.path, disabledServerNames };
+  });
+}
 function buildManagedEntries(config, gatewayUrl, localToken) {
   const entries = Object.entries(config.servers);
   return entries.map(([name, spec]) => ({
@@ -1752,7 +1793,8 @@ function syncAllClients(config, secrets, targetClients) {
       managedEntries,
       managedIndex,
       managedIndexPath,
-      sourceEntriesToRemove: Array.from(sourceEntriesToRemove.get(adapter.id) ?? [])
+      sourceEntriesToRemove: Array.from(sourceEntriesToRemove.get(adapter.id) ?? []),
+      projectScopes: buildProjectScopes(config)
     });
     results.push(result);
   }
@@ -1887,11 +1929,11 @@ function maybePrefixBearer(target, value, raw = false) {
 // src/core/spawn-env.ts
 import os from "node:os";
 import path11 from "node:path";
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 function existingNvmCurrentBin() {
   const nvmDir = process.env.NVM_DIR ?? path11.join(os.homedir(), ".nvm");
   const current = path11.join(nvmDir, "current", "bin");
-  return fs6.existsSync(current) ? current : null;
+  return fs7.existsSync(current) ? current : null;
 }
 function buildEnrichedPath(current = process.env.PATH ?? "") {
   const candidates = [
@@ -2211,7 +2253,7 @@ async function getOAuthAccessToken(serverName, spec, secrets, options = {}) {
 var APP_VERSION = "0.1.3";
 
 // src/core/update.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path12 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 function compareVersions(a, b) {
@@ -2251,17 +2293,17 @@ async function checkForUpdates() {
 }
 function getStagedUpdate() {
   const stagedPath = getStagedVersionPath();
-  if (!fs7.existsSync(stagedPath)) {
+  if (!fs8.existsSync(stagedPath)) {
     return null;
   }
   try {
-    const raw = fs7.readFileSync(stagedPath, "utf8");
+    const raw = fs8.readFileSync(stagedPath, "utf8");
     const info = JSON.parse(raw);
     if (!info.version || !info.cliPath) {
       return null;
     }
     const absoluteCliPath = path12.isAbsolute(info.cliPath) ? info.cliPath : path12.join(getUpdatesDir(), info.cliPath);
-    if (!fs7.existsSync(absoluteCliPath)) {
+    if (!fs8.existsSync(absoluteCliPath)) {
       return null;
     }
     return {
@@ -2280,15 +2322,15 @@ function stageUpdate(version, cliPath) {
     cliPath: path12.isAbsolute(cliPath) ? path12.relative(updatesDir, cliPath) : cliPath,
     stagedAt: new Date().toISOString()
   };
-  fs7.writeFileSync(getStagedVersionPath(), JSON.stringify(stagedInfo, null, 2), "utf8");
+  fs8.writeFileSync(getStagedVersionPath(), JSON.stringify(stagedInfo, null, 2), "utf8");
 }
 function shouldUseStagedCli(stagedVersion, currentVersion) {
   return compareVersions(stagedVersion, currentVersion) > 0;
 }
 function clearStagedUpdate() {
   const stagedPath = getStagedVersionPath();
-  if (fs7.existsSync(stagedPath)) {
-    fs7.unlinkSync(stagedPath);
+  if (fs8.existsSync(stagedPath)) {
+    fs8.unlinkSync(stagedPath);
   }
 }
 function getStagedCliPath() {
@@ -2297,10 +2339,10 @@ function getStagedCliPath() {
 }
 function removeOldVersions(keepCount = 2) {
   const updatesDir = getUpdatesDir();
-  if (!fs7.existsSync(updatesDir)) {
+  if (!fs8.existsSync(updatesDir)) {
     return;
   }
-  const entries = fs7.readdirSync(updatesDir, { withFileTypes: true });
+  const entries = fs8.readdirSync(updatesDir, { withFileTypes: true });
   const versionDirs = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith("v")).map((entry) => entry.name).sort((a, b) => compareVersions(b.slice(1), a.slice(1)));
   if (versionDirs.length <= keepCount) {
     return;
@@ -2308,20 +2350,20 @@ function removeOldVersions(keepCount = 2) {
   for (const oldVersion of versionDirs.slice(keepCount)) {
     const oldPath = path12.join(updatesDir, oldVersion);
     try {
-      fs7.rmSync(oldPath, { recursive: true, force: true });
+      fs8.rmSync(oldPath, { recursive: true, force: true });
     } catch {}
   }
 }
 
 // src/core/update-manager.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path13 from "node:path";
 import { execSync, spawn } from "node:child_process";
 function acquireLock() {
   const lockPath = getUpdateLockPath();
   try {
     ensureDir(path13.dirname(lockPath));
-    fs8.writeFileSync(lockPath, `${process.pid}
+    fs9.writeFileSync(lockPath, `${process.pid}
 `, { flag: "wx" });
     return true;
   } catch {
@@ -2331,25 +2373,25 @@ function acquireLock() {
 function releaseLock() {
   const lockPath = getUpdateLockPath();
   try {
-    fs8.unlinkSync(lockPath);
+    fs9.unlinkSync(lockPath);
   } catch {}
 }
 function isUpdateInProgress() {
   const lockPath = getUpdateLockPath();
-  if (!fs8.existsSync(lockPath)) {
+  if (!fs9.existsSync(lockPath)) {
     return false;
   }
   try {
-    const raw = fs8.readFileSync(lockPath, "utf8").trim();
+    const raw = fs9.readFileSync(lockPath, "utf8").trim();
     const pid = Number(raw);
     if (!Number.isFinite(pid) || pid <= 0) {
-      fs8.unlinkSync(lockPath);
+      fs9.unlinkSync(lockPath);
       return false;
     }
     process.kill(pid, 0);
     return true;
   } catch {
-    fs8.unlinkSync(lockPath);
+    fs9.unlinkSync(lockPath);
     return false;
   }
 }
@@ -2361,7 +2403,7 @@ async function downloadAndStageUpdate() {
   const targetVersion = updateStatus.latestVersion;
   const updatesDir = getUpdatesDir();
   const versionDir = path13.join(updatesDir, `v${targetVersion}`);
-  if (fs8.existsSync(versionDir)) {
+  if (fs9.existsSync(versionDir)) {
     const existingStaged = getStagedUpdate();
     if (existingStaged?.version === targetVersion) {
       return { success: false, error: `Version ${targetVersion} already staged` };
@@ -2374,7 +2416,7 @@ async function downloadAndStageUpdate() {
       stdio: ["pipe", "pipe", "pipe"]
     });
     const tarballPath = path13.join(versionDir, `kwonye-mcpx-${targetVersion}.tgz`);
-    if (!fs8.existsSync(tarballPath)) {
+    if (!fs9.existsSync(tarballPath)) {
       throw new Error("Downloaded tarball not found");
     }
     execSync(`tar -xzf ${tarballPath} --strip-components=1`, {
@@ -2386,7 +2428,7 @@ async function downloadAndStageUpdate() {
       stdio: ["pipe", "pipe", "pipe"]
     });
     const cliPath = path13.join(versionDir, "dist", "cli.js");
-    if (!fs8.existsSync(cliPath)) {
+    if (!fs9.existsSync(cliPath)) {
       throw new Error("CLI entry point not found in downloaded package");
     }
     stageUpdate(targetVersion, cliPath);
@@ -2394,7 +2436,7 @@ async function downloadAndStageUpdate() {
     return { success: true, version: targetVersion };
   } catch (error) {
     try {
-      fs8.rmSync(versionDir, { recursive: true, force: true });
+      fs9.rmSync(versionDir, { recursive: true, force: true });
     } catch {}
     return {
       success: false,
@@ -2472,7 +2514,7 @@ function performRollback() {
 }
 
 // src/core/daemon.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import net from "node:net";
 import { spawn as spawn2 } from "node:child_process";
 
@@ -3416,10 +3458,10 @@ function createGatewayServer(options) {
 
 // src/core/daemon.ts
 function readPidFromFile(pidPath = getPidPath()) {
-  if (!fs9.existsSync(pidPath)) {
+  if (!fs10.existsSync(pidPath)) {
     return null;
   }
-  const raw = fs9.readFileSync(pidPath, "utf8").trim();
+  const raw = fs10.readFileSync(pidPath, "utf8").trim();
   if (!raw) {
     return null;
   }
@@ -3521,7 +3563,7 @@ async function startDaemon(config, cliPath, secrets) {
       };
     }
     try {
-      fs9.unlinkSync(getPidPath());
+      fs10.unlinkSync(getPidPath());
     } catch {}
   }
   const port = await resolveGatewayPort(config);
@@ -3530,7 +3572,7 @@ async function startDaemon(config, cliPath, secrets) {
   const logPath = getLogPath();
   ensureParentDir(pidPath);
   ensureParentDir(logPath);
-  const logFd = fs9.openSync(logPath, "a", 384);
+  const logFd = fs10.openSync(logPath, "a", 384);
   const child = spawn2(process.execPath, [cliPath, "daemon", "run", "--port", String(port)], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -3540,7 +3582,7 @@ async function startDaemon(config, cliPath, secrets) {
     }
   });
   child.unref();
-  fs9.writeFileSync(pidPath, `${child.pid}
+  fs10.writeFileSync(pidPath, `${child.pid}
 `, { mode: 384 });
   startBackgroundUpdateCheck();
   await waitForGatewayReady(port, token);
@@ -3564,7 +3606,7 @@ function stopDaemon() {
     process.kill(pid, "SIGTERM");
   } catch {}
   try {
-    fs9.unlinkSync(pidPath);
+    fs10.unlinkSync(pidPath);
   } catch {}
   return {
     stopped: true,
@@ -3577,10 +3619,10 @@ async function restartDaemon(config, cliPath, secrets) {
 }
 function readDaemonLogs(maxLines = 200) {
   const logPath = getLogPath();
-  if (!fs9.existsSync(logPath)) {
+  if (!fs10.existsSync(logPath)) {
     return "";
   }
-  const lines = fs9.readFileSync(logPath, "utf8").split(`
+  const lines = fs10.readFileSync(logPath, "utf8").split(`
 `);
   return lines.slice(Math.max(lines.length - maxLines, 0)).join(`
 `);
@@ -3697,11 +3739,11 @@ async function buildStatusReport(config, managedIndex, daemon = getDaemonStatus(
       tokenCount
     };
     if (serverEntry.enabled && tokenCount) {
-      const matchingProject = projectEntries.find((p) => name.startsWith(`${p.name}.`));
-      if (matchingProject) {
-        totalProjectTokens[matchingProject.path] = (totalProjectTokens[matchingProject.path] ?? 0) + tokenCount.total;
-      } else {
-        totalGlobalTokens += tokenCount.total;
+      totalGlobalTokens += tokenCount.total;
+      for (const projectEntry of projectEntries) {
+        if (!(projectEntry.disabledServers ?? []).includes(name)) {
+          totalProjectTokens[projectEntry.path] = (totalProjectTokens[projectEntry.path] ?? 0) + tokenCount.total;
+        }
       }
     }
     return serverEntry;