@kwonye/mcpx 0.1.75 → 0.1.77

package/dist/{cli-e9hdd44n.js → cli-htm5cf82.js}

@@ -1,238 +1,45 @@
 import {
-  isServerEnabled,
-  normalizeServerSpecEnabled
-} from "./cli-q8de7zb0.js";
-
-// src/core/paths.ts
-import os from "node:os";
-import path from "node:path";
-import fs from "node:fs";
-function envOrDefault(value, fallback) {
-  if (value && value.trim().length > 0) {
-    return value;
-  }
-  return fallback;
-}
-function homeDir() {
-  return process.env.HOME ?? os.homedir();
-}
-function getConfigRoot() {
-  return envOrDefault(process.env.MCPX_CONFIG_HOME ?? process.env.XDG_CONFIG_HOME, path.join(homeDir(), ".config"));
-}
-function getDataRoot() {
-  return envOrDefault(process.env.MCPX_DATA_HOME ?? process.env.XDG_DATA_HOME, path.join(homeDir(), ".local", "share"));
-}
-function getStateRoot() {
-  return envOrDefault(process.env.MCPX_STATE_HOME ?? process.env.XDG_STATE_HOME, path.join(homeDir(), ".local", "state"));
-}
-function getConfigPath() {
-  return path.join(getConfigRoot(), "mcpx", "config.json");
-}
-function getSkillsDir() {
-  return path.join(getConfigRoot(), "mcpx", "skills");
-}
-function getManagedIndexPath() {
-  return path.join(getDataRoot(), "mcpx", "managed-index.json");
-}
-function getSecretNamesPath() {
-  return path.join(getDataRoot(), "mcpx", "secret-names.json");
-}
-function getRuntimeDir() {
-  return path.join(getStateRoot(), "mcpx", "runtime");
-}
-function getLogDir() {
-  return path.join(getStateRoot(), "mcpx", "logs");
-}
-function getPidPath() {
-  return path.join(getRuntimeDir(), "daemon.pid");
-}
-function getLogPath() {
-  return path.join(getLogDir(), "daemon.log");
-}
-function getUpdatesDir() {
-  return path.join(getDataRoot(), "mcpx", "updates");
-}
-function getStagedVersionPath() {
-  return path.join(getUpdatesDir(), "staged-version.json");
-}
-function getUpdateLockPath() {
-  return path.join(getUpdatesDir(), ".update.lock");
-}
-function ensureDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
-}
-function ensureParentDir(filePath) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-}
-
-// src/core/config.ts
-import { z } from "zod";
-
-// src/util/fs.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
-import crypto from "node:crypto";
-function readJsonFile(filePath, fallback) {
-  if (!fs2.existsSync(filePath)) {
-    return fallback;
-  }
-  try {
-    const raw = fs2.readFileSync(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return fallback;
-  }
-}
-function writeJsonAtomic(filePath, data) {
-  fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
-  const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  const content = `${JSON.stringify(data, null, 2)}
-`;
-  fs2.writeFileSync(tempPath, content, { mode: 384 });
-  fs2.renameSync(tempPath, filePath);
-}
-function sha256(value) {
-  return crypto.createHash("sha256").update(value).digest("hex");
-}
-
-// src/core/config.ts
-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 httpServerSchema = z.object({
-  transport: z.literal("http"),
-  url: z.url(),
-  headers: z.record(z.string(), z.string()).optional(),
-  enabled: z.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 serverSchema = z.discriminatedUnion("transport", [httpServerSchema, stdioServerSchema]);
-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)
-  }).default({
-    port: 37373,
-    tokenRef: "secret://local_gateway_token",
-    autoStart: true
-  }),
-  servers: z.record(z.string(), serverSchema).default({}),
-  clients: z.record(z.string(), clientStateSchema).default({})
-});
-function defaultConfig() {
-  return {
-    schemaVersion: 1,
-    gateway: {
-      port: 37373,
-      tokenRef: "secret://local_gateway_token",
-      autoStart: true
-    },
-    servers: {},
-    clients: {}
-  };
-}
-function loadConfig(configPath = getConfigPath()) {
-  const raw = readJsonFile(configPath, defaultConfig());
-  const parsed = configSchema.safeParse(raw);
-  if (!parsed.success) {
-    return defaultConfig();
-  }
-  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)) {
-      clientEntries[key] = value;
-    }
-  }
-  const servers = Object.fromEntries(Object.entries(parsed.data.servers).map(([name, spec]) => [name, normalizeServerSpecEnabled(spec)]));
-  return {
-    schemaVersion: 1,
-    gateway: parsed.data.gateway,
-    servers,
-    clients: clientEntries
-  };
-}
-function saveConfig(config, configPath = getConfigPath()) {
-  config.servers = Object.fromEntries(Object.entries(config.servers).map(([name, spec]) => [name, normalizeServerSpecEnabled(spec)]));
-  writeJsonAtomic(configPath, config);
-}
-
-// src/core/registry.ts
-function validateServerName(name) {
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,62}$/.test(name)) {
-    throw new Error("Invalid server name. Use 1-63 chars: letters, numbers, '.', '-', '_' and start with alphanumeric.");
-  }
-}
-function addServer(config, name, spec, force = false) {
-  validateServerName(name);
-  if (config.servers[name] && !force) {
-    throw new Error(`Server "${name}" already exists. Use --force to overwrite.`);
-  }
-  config.servers[name] = normalizeServerSpecEnabled(spec);
-}
-function removeServer(config, name, force = false) {
-  if (!config.servers[name] && !force) {
-    throw new Error(`Server "${name}" does not exist.`);
-  }
-  delete config.servers[name];
-}
-function updateServer(config, name, spec) {
-  validateServerName(name);
-  if (!config.servers[name]) {
-    throw new Error(`Server "${name}" does not exist.`);
-  }
-  config.servers[name] = normalizeServerSpecEnabled(spec);
-}
-function setServerEnabled(config, name, enabled) {
-  const existing = config.servers[name];
-  if (!existing) {
-    throw new Error(`Server "${name}" does not exist.`);
-  }
-  config.servers[name] = {
-    ...existing,
-    enabled
-  };
-}
-function getGatewayTokenSecretName(config) {
-  if (!config.gateway.tokenRef.startsWith("secret://")) {
-    return "local_gateway_token";
-  }
-  return config.gateway.tokenRef.slice("secret://".length) || "local_gateway_token";
-}
-function ensureGatewayToken(config, secrets) {
-  const secretName = getGatewayTokenSecretName(config);
-  const existing = secrets.getSecret(secretName);
-  if (existing) {
-    return existing;
-  }
-  return secrets.rotateLocalToken(secretName);
-}
+  loadMergedConfig,
+  saveConfig
+} from "./cli-7bsf6akp.js";
+import {
+  SecretsManager,
+  ensureGatewayToken,
+  getGatewayTokenSecretName
+} from "./cli-s4py8ckf.js";
+import {
+  ensureDir,
+  ensureParentDir,
+  getLogPath,
+  getManagedIndexPath,
+  getPidPath,
+  getSkillsDir,
+  getStagedVersionPath,
+  getUpdateLockPath,
+  getUpdatesDir,
+  homeDir,
+  readJsonFile,
+  sha256,
+  writeJsonAtomic
+} from "./cli-fsf33sgp.js";
+import {
+  isServerEnabled
+} from "./cli-s4gspqdf.js";
 
 // src/core/skills.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs from "node:fs";
+import path from "node:path";
 function listSkills() {
   const skillsDir = getSkillsDir();
-  if (!fs3.existsSync(skillsDir)) {
+  if (!fs.existsSync(skillsDir)) {
     return [];
   }
-  const files = fs3.readdirSync(skillsDir);
+  const files = fs.readdirSync(skillsDir);
   const skills = [];
   for (const file of files) {
     if (file.endsWith(".md")) {
-      const id = path3.basename(file, ".md");
-      const content = fs3.readFileSync(path3.join(skillsDir, file), "utf-8");
+      const id = path.basename(file, ".md");
+      const content = fs.readFileSync(path.join(skillsDir, file), "utf-8");
       skills.push({ id, content });
     }
   }
@@ -240,134 +47,52 @@ function listSkills() {
 }
 function getSkill(id) {
   const skillsDir = getSkillsDir();
-  const filePath = path3.join(skillsDir, `${id}.md`);
-  if (!fs3.existsSync(filePath)) {
+  const filePath = path.join(skillsDir, `${id}.md`);
+  if (!fs.existsSync(filePath)) {
     return null;
   }
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs.readFileSync(filePath, "utf-8");
   return { id, content };
 }
 function saveSkill(id, content) {
   const skillsDir = getSkillsDir();
   ensureDir(skillsDir);
-  const filePath = path3.join(skillsDir, `${id}.md`);
-  fs3.writeFileSync(filePath, content, "utf-8");
+  const filePath = path.join(skillsDir, `${id}.md`);
+  fs.writeFileSync(filePath, content, "utf-8");
 }
 function deleteSkill(id) {
   const skillsDir = getSkillsDir();
-  const filePath = path3.join(skillsDir, `${id}.md`);
-  if (fs3.existsSync(filePath)) {
-    fs3.unlinkSync(filePath);
-  }
-}
-
-// src/core/secrets.ts
-import { execFileSync } from "node:child_process";
-import crypto2 from "node:crypto";
-import fs4 from "node:fs";
-function parseSecretRef(ref) {
-  if (!ref.startsWith("secret://")) {
-    return null;
+  const filePath = path.join(skillsDir, `${id}.md`);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
   }
-  const name = ref.slice("secret://".length);
-  return name.length > 0 ? name : null;
-}
-
-class SecretsManager {
-  service;
-  nameIndexPath;
-  constructor(service = "mcpx", nameIndexPath = getSecretNamesPath()) {
-    this.service = service;
-    this.nameIndexPath = nameIndexPath;
-  }
-  loadNameIndex() {
-    return readJsonFile(this.nameIndexPath, { names: [] });
-  }
-  saveNameIndex(index) {
-    const deduped = Array.from(new Set(index.names)).sort();
-    writeJsonAtomic(this.nameIndexPath, { names: deduped });
-  }
-  trackSecretName(name) {
-    const index = this.loadNameIndex();
-    if (!index.names.includes(name)) {
-      index.names.push(name);
-      this.saveNameIndex(index);
-    }
-  }
-  untrackSecretName(name) {
-    const index = this.loadNameIndex();
-    index.names = index.names.filter((entry) => entry !== name);
-    this.saveNameIndex(index);
-  }
-  listSecretNames() {
-    return this.loadNameIndex().names;
-  }
-  setSecret(name, value) {
-    if (process.platform !== "darwin") {
-      throw new Error("OS keychain integration is currently implemented for macOS only.");
-    }
-    execFileSync("security", ["add-generic-password", "-U", "-a", name, "-s", this.service, "-w", value], {
-      stdio: "ignore"
-    });
-    this.trackSecretName(name);
-  }
-  removeSecret(name) {
-    if (process.platform === "darwin") {
-      try {
-        execFileSync("security", ["delete-generic-password", "-a", name, "-s", this.service], {
-          stdio: "ignore"
-        });
-      } catch {}
-    }
-    this.untrackSecretName(name);
-  }
-  getSecret(name) {
-    const envOverride = process.env[`MCPX_SECRET_${name}`];
-    if (envOverride && envOverride.length > 0) {
-      return envOverride;
-    }
-    if (process.platform !== "darwin") {
-      return null;
-    }
-    try {
-      return execFileSync("security", ["find-generic-password", "-w", "-a", name, "-s", this.service], {
-        encoding: "utf8"
-      }).trim();
-    } catch {
-      return null;
-    }
-  }
-  resolveMaybeSecret(value) {
-    const secretName = parseSecretRef(value);
-    if (!secretName) {
-      return value;
-    }
-    const secret = this.getSecret(secretName);
-    if (!secret) {
-      throw new Error(`Secret not found: ${secretName}`);
-    }
-    return secret;
-  }
-  rotateLocalToken(secretName = "local_gateway_token") {
-    const token = crypto2.randomBytes(32).toString("base64url");
-    this.setSecret(secretName, token);
-    return token;
-  }
-}
-function readSecretValueFromStdin() {
-  if (process.stdin.isTTY) {
-    throw new Error("No value provided. Use --value or pipe a value via stdin.");
-  }
-  const content = fs4.readFileSync(process.stdin.fd, "utf8").trim();
-  if (content.length === 0) {
-    throw new Error("Empty secret value provided.");
-  }
-  return content;
 }
 
 // src/core/auth-probe.ts
 var JSON_RPC_VERSION = "2.0";
 var DEFAULT_AUTH_PROBE_TIMEOUT_MS = 8000;
+var AUTH_KEYWORDS = [
+  "unauthorized",
+  "unauthenticated",
+  "forbidden",
+  "authentication",
+  "authorization",
+  "api key",
+  "api_key",
+  "apikey",
+  "credentials",
+  "access denied",
+  "auth required",
+  "x-api-key",
+  "invalid key",
+  "missing header",
+  "not authenticated",
+  "auth token"
+];
+function isAuthRelatedMessage(message) {
+  const lower = message.toLowerCase();
+  return AUTH_KEYWORDS.some((kw) => lower.includes(kw));
+}
 function resolveHeaders(spec, secrets) {
   const headers = {
     "content-type": "application/json",
@@ -401,6 +126,22 @@ async function probeHttpAuthRequirement(spec, secrets, timeoutMs = DEFAULT_AUTH_
         wwwAuthenticate: response.headers.get("www-authenticate") ?? undefined
       };
     }
+    if (response.status === 200) {
+      try {
+        const body = await response.json();
+        const err = body?.error;
+        if (err && typeof err === "object" && !("result" in body)) {
+          const message = typeof err.message === "string" ? err.message : "";
+          if (message && isAuthRelatedMessage(message)) {
+            return {
+              authRequired: true,
+              status: response.status,
+              error: `JSON-RPC error: ${message}`
+            };
+          }
+        }
+      } catch {}
+    }
     return {
       authRequired: false,
       status: response.status
@@ -416,9 +157,132 @@ async function probeHttpAuthRequirement(spec, secrets, timeoutMs = DEFAULT_AUTH_
   }
 }
 
+// src/core/registry-client.ts
+var REGISTRY_BASE = "https://registry.modelcontextprotocol.io";
+async function fetchRegistryServerDetail(name) {
+  const encoded = encodeURIComponent(name);
+  const response = await fetch(`${REGISTRY_BASE}/v0.1/servers/${encoded}/versions/latest`, {
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new Error(`Registry API error: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.server;
+}
+var PACKAGE_PRIORITY = {
+  npm: 1,
+  pypi: 2,
+  nuget: 3,
+  oci: 4,
+  mcpb: 5
+};
+var RUNTIME_HINT = {
+  npm: "npx",
+  pypi: "uvx",
+  nuget: "dnx"
+};
+function selectBestPackage(packages = [], remotes = []) {
+  const stdioPkgs = packages.filter((p) => p.transport.type === "stdio").sort((a, b) => (PACKAGE_PRIORITY[a.registryType] ?? 99) - (PACKAGE_PRIORITY[b.registryType] ?? 99));
+  if (stdioPkgs.length > 0) {
+    return { kind: "package", package: stdioPkgs[0] };
+  }
+  const httpRemotes = remotes.filter((r) => r.type === "streamable-http" || r.type === "sse");
+  if (httpRemotes.length > 0) {
+    return { kind: "remote", remote: httpRemotes[0] };
+  }
+  if (packages.length > 0) {
+    return { kind: "package", package: packages[0] };
+  }
+  if (remotes.length > 0) {
+    return { kind: "remote", remote: remotes[0] };
+  }
+  throw new Error("Server has no packages or remotes");
+}
+function extractRequiredInputs(option) {
+  const inputs = [];
+  if (option.kind === "package" && option.package?.environmentVariables) {
+    for (const env of option.package.environmentVariables) {
+      if (env.isRequired && !env.default) {
+        inputs.push({
+          name: env.name,
+          description: env.description,
+          isSecret: env.isSecret ?? false,
+          kind: "env"
+        });
+      }
+    }
+    for (const arg of option.package.packageArguments ?? []) {
+      if (arg.isRequired && !arg.value && !arg.default) {
+        inputs.push({
+          name: arg.name ?? arg.valueHint ?? "arg",
+          description: arg.description,
+          isSecret: false,
+          kind: "arg"
+        });
+      }
+    }
+  }
+  if (option.kind === "remote" && option.remote?.headers) {
+    for (const header of option.remote.headers) {
+      if (header.isRequired && !header.default) {
+        inputs.push({
+          name: header.name,
+          description: header.description,
+          isSecret: header.isSecret ?? false,
+          kind: "header"
+        });
+      }
+    }
+  }
+  return inputs;
+}
+function mapRegistryToSpec(_name, option, resolvedValues) {
+  if (option.kind === "remote") {
+    const headers = {};
+    for (const header of option.remote?.headers ?? []) {
+      const value = resolvedValues[header.name] ?? header.default;
+      if (value)
+        headers[header.name] = value;
+    }
+    return {
+      transport: "http",
+      url: option.remote.url,
+      ...Object.keys(headers).length > 0 ? { headers } : {}
+    };
+  }
+  const pkg = option.package;
+  const runtime = pkg.runtimeHint ?? RUNTIME_HINT[pkg.registryType] ?? "npx";
+  const args = [];
+  const identifier = pkg.version ? `${pkg.identifier}@${pkg.version}` : pkg.identifier;
+  args.push(identifier);
+  for (const arg of pkg.packageArguments ?? []) {
+    const value = arg.value ?? resolvedValues[arg.name ?? arg.valueHint ?? ""] ?? arg.default;
+    if (!value)
+      continue;
+    if (arg.type === "named" && arg.name) {
+      args.push(arg.name, value);
+    } else {
+      args.push(value);
+    }
+  }
+  const env = {};
+  for (const envVar of pkg.environmentVariables ?? []) {
+    const value = resolvedValues[envVar.name] ?? envVar.default;
+    if (value)
+      env[envVar.name] = value;
+  }
+  return {
+    transport: "stdio",
+    command: runtime,
+    args,
+    ...Object.keys(env).length > 0 ? { env } : {}
+  };
+}
+
 // src/adapters/claude.ts
-import path4 from "node:path";
-import { z as z2 } from "zod";
+import path2 from "node:path";
+import { z } from "zod";
 
 // src/adapters/utils/index.ts
 function getManagedEntryNames(managedIndex, clientId) {
@@ -546,22 +410,22 @@ function syncMcpExcludedArray(raw, managedNames, managedEntries) {
 }
 
 // src/adapters/claude.ts
-var stringMapSchema = z2.record(z2.string(), z2.string());
-var claudeEntrySchema = z2.object({
-  type: z2.string().optional(),
-  url: z2.string().min(1).optional(),
+var stringMapSchema = z.record(z.string(), z.string());
+var claudeEntrySchema = z.object({
+  type: z.string().optional(),
+  url: z.string().min(1).optional(),
   headers: stringMapSchema.optional(),
-  command: z2.string().min(1).optional(),
-  args: z2.array(z2.string()).optional(),
+  command: z.string().min(1).optional(),
+  args: z.array(z.string()).optional(),
   env: stringMapSchema.optional(),
-  cwd: z2.string().min(1).optional(),
-  disabled: z2.boolean().optional()
+  cwd: z.string().min(1).optional(),
+  disabled: z.boolean().optional()
 }).passthrough();
 
 class ClaudeAdapter {
   id = "claude";
   detectConfigPath() {
-    return path4.join(homeDir(), ".claude.json");
+    return path2.join(homeDir(), ".claude.json");
   }
   supportsHttp() {
     return true;
@@ -673,24 +537,24 @@ class ClaudeAdapter {
 }
 
 // src/adapters/claude-desktop.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-import path5 from "node:path";
-import { z as z3 } from "zod";
-var stringMapSchema2 = z3.record(z3.string(), z3.string());
-var claudeDesktopEntrySchema = z3.object({
-  type: z3.string().optional(),
-  url: z3.string().min(1).optional(),
+import { execFileSync } from "node:child_process";
+import path3 from "node:path";
+import { z as z2 } from "zod";
+var stringMapSchema2 = z2.record(z2.string(), z2.string());
+var claudeDesktopEntrySchema = z2.object({
+  type: z2.string().optional(),
+  url: z2.string().min(1).optional(),
   headers: stringMapSchema2.optional(),
-  command: z3.string().min(1).optional(),
-  args: z3.array(z3.string()).optional(),
+  command: z2.string().min(1).optional(),
+  args: z2.array(z2.string()).optional(),
   env: stringMapSchema2.optional(),
-  cwd: z3.string().min(1).optional(),
-  disabled: z3.boolean().optional()
+  cwd: z2.string().min(1).optional(),
+  disabled: z2.boolean().optional()
 }).passthrough();
 function buildProxyEntry(entry) {
   const upstreamName = entry.name.replace(/ \(mcpx\)$/, "");
   try {
-    const mcpxPath = execFileSync2("which", ["mcpx"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const mcpxPath = execFileSync("which", ["mcpx"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     if (mcpxPath)
       return { command: mcpxPath, args: ["proxy", upstreamName] };
   } catch {}
@@ -700,7 +564,13 @@ function buildProxyEntry(entry) {
 class ClaudeDesktopAdapter {
   id = "claude-desktop";
   detectConfigPath() {
-    return path5.join(homeDir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    if (process.platform === "linux") {
+      return path3.join(homeDir(), ".config", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "win32") {
+      return path3.join(process.env.APPDATA ?? "", "Claude", "claude_desktop_config.json");
+    }
+    return path3.join(homeDir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   supportsHttp() {
     return true;
@@ -798,31 +668,31 @@ class ClaudeDesktopAdapter {
 }
 
 // src/adapters/codex.ts
-import path6 from "node:path";
-import fs5 from "node:fs";
+import path4 from "node:path";
+import fs2 from "node:fs";
 import { parse, stringify } from "@iarna/toml";
-import { z as z4 } from "zod";
-var stringMapSchema3 = z4.preprocess((value) => {
+import { z as z3 } from "zod";
+var stringMapSchema3 = z3.preprocess((value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return value;
   }
   return Object.fromEntries(Object.entries(value));
-}, z4.record(z4.string(), z4.string()));
-var codexEntrySchema = z4.object({
-  enabled: z4.boolean().optional(),
-  url: z4.string().min(1).optional(),
+}, z3.record(z3.string(), z3.string()));
+var codexEntrySchema = z3.object({
+  enabled: z3.boolean().optional(),
+  url: z3.string().min(1).optional(),
   headers: stringMapSchema3.optional(),
   http_headers: stringMapSchema3.optional(),
-  command: z4.string().min(1).optional(),
-  args: z4.array(z4.string()).optional(),
+  command: z3.string().min(1).optional(),
+  args: z3.array(z3.string()).optional(),
   env: stringMapSchema3.optional(),
-  cwd: z4.string().min(1).optional()
+  cwd: z3.string().min(1).optional()
 }).passthrough();
 
 class CodexAdapter {
   id = "codex";
   detectConfigPath() {
-    return path6.join(homeDir(), ".codex", "config.toml");
+    return path4.join(homeDir(), ".codex", "config.toml");
   }
   supportsHttp() {
     return true;
@@ -830,10 +700,10 @@ class CodexAdapter {
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
     const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs5.existsSync(configPath)) {
+    if (!configPath || !fs2.existsSync(configPath)) {
       return result;
     }
-    const existing = fs5.readFileSync(configPath, "utf8");
+    const existing = fs2.readFileSync(configPath, "utf8");
     const doc = existing.trim().length > 0 ? parse(existing) : {};
     const mcpServers = doc.mcp_servers ?? {};
     for (const [name, rawEntry] of Object.entries(mcpServers)) {
@@ -888,7 +758,7 @@ class CodexAdapter {
       return errorResult(this.id, undefined, "Unable to resolve Codex config.toml path.");
     }
     try {
-      const existing = fs5.existsSync(configPath) ? fs5.readFileSync(configPath, "utf8") : "";
+      const existing = fs2.existsSync(configPath) ? fs2.readFileSync(configPath, "utf8") : "";
       const doc = existing.trim().length > 0 ? parse(existing) : {};
       const mcpServers = doc.mcp_servers ?? {};
       removeSourceEntries(mcpServers, options.sourceEntriesToRemove);
@@ -909,10 +779,10 @@ class CodexAdapter {
         mcpServers[name] = entry;
       }
       doc.mcp_servers = mcpServers;
-      fs5.mkdirSync(path6.dirname(configPath), { recursive: true });
+      fs2.mkdirSync(path4.dirname(configPath), { recursive: true });
       const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
-      fs5.writeFileSync(tmpPath, stringify(doc), { mode: 384 });
-      fs5.renameSync(tmpPath, configPath);
+      fs2.writeFileSync(tmpPath, stringify(doc), { mode: 384 });
+      fs2.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) {
@@ -922,24 +792,30 @@ class CodexAdapter {
 }
 
 // src/adapters/cursor.ts
-import path7 from "node:path";
-import { z as z5 } from "zod";
-var stringMapSchema4 = z5.record(z5.string(), z5.string());
-var cursorEntrySchema = z5.object({
-  type: z5.string().optional(),
-  url: z5.string().min(1).optional(),
+import path5 from "node:path";
+import { z as z4 } from "zod";
+var stringMapSchema4 = z4.record(z4.string(), z4.string());
+var cursorEntrySchema = z4.object({
+  type: z4.string().optional(),
+  url: z4.string().min(1).optional(),
   headers: stringMapSchema4.optional(),
-  command: z5.string().min(1).optional(),
-  args: z5.array(z5.string()).optional(),
+  command: z4.string().min(1).optional(),
+  args: z4.array(z4.string()).optional(),
   env: stringMapSchema4.optional(),
-  cwd: z5.string().min(1).optional(),
-  disabled: z5.boolean().optional()
+  cwd: z4.string().min(1).optional(),
+  disabled: z4.boolean().optional()
 }).passthrough();
 
 class CursorAdapter {
   id = "cursor";
   detectConfigPath() {
-    return path7.join(homeDir(), "Library", "Application Support", "Cursor", "User", "mcp.json");
+    if (process.platform === "linux") {
+      return path5.join(homeDir(), ".config", "Cursor", "User", "mcp.json");
+    }
+    if (process.platform === "win32") {
+      return path5.join(process.env.APPDATA ?? "", "Cursor", "User", "mcp.json");
+    }
+    return path5.join(homeDir(), "Library", "Application Support", "Cursor", "User", "mcp.json");
   }
   supportsHttp() {
     return true;
@@ -1045,24 +921,36 @@ class CursorAdapter {
 }
 
 // src/adapters/cline.ts
-import path8 from "node:path";
-import fs6 from "node:fs";
-import { z as z6 } from "zod";
-var stringMapSchema5 = z6.record(z6.string(), z6.string());
-var clineEntrySchema = z6.object({
-  transportType: z6.string().optional(),
-  url: z6.string().min(1).optional(),
+import path6 from "node:path";
+import fs3 from "node:fs";
+import { z as z5 } from "zod";
+var stringMapSchema5 = z5.record(z5.string(), z5.string());
+var clineEntrySchema = z5.object({
+  transportType: z5.string().optional(),
+  url: z5.string().min(1).optional(),
   headers: stringMapSchema5.optional(),
-  command: z6.string().min(1).optional(),
-  args: z6.array(z6.string()).optional(),
+  command: z5.string().min(1).optional(),
+  args: z5.array(z5.string()).optional(),
   env: stringMapSchema5.optional(),
-  cwd: z6.string().min(1).optional(),
-  disabled: z6.boolean().optional()
+  cwd: z5.string().min(1).optional(),
+  disabled: z5.boolean().optional()
 }).passthrough();
 function getCandidatePaths() {
+  if (process.platform === "linux") {
+    return [
+      path6.join(homeDir(), ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path6.join(homeDir(), ".config", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+    ];
+  }
+  if (process.platform === "win32") {
+    return [
+      path6.join(process.env.APPDATA ?? "", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+      path6.join(process.env.APPDATA ?? "", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+    ];
+  }
   return [
-    path8.join(homeDir(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-    path8.join(homeDir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+    path6.join(homeDir(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+    path6.join(homeDir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
   ];
 }
 
@@ -1071,7 +959,7 @@ class ClineAdapter {
   detectConfigPath() {
     const candidates = getCandidatePaths();
     for (const candidate of candidates) {
-      if (fs6.existsSync(candidate)) {
+      if (fs3.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -1083,7 +971,7 @@ class ClineAdapter {
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
     const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs6.existsSync(configPath)) {
+    if (!configPath || !fs3.existsSync(configPath)) {
       return result;
     }
     const raw = readJsonFile(configPath, {});
@@ -1178,24 +1066,24 @@ class ClineAdapter {
 }
 
 // src/adapters/kiro.ts
-import fs7 from "node:fs";
-import path9 from "node:path";
-import { z as z7 } from "zod";
-var stringMapSchema6 = z7.record(z7.string(), z7.string());
-var kiroEntrySchema = z7.object({
-  url: z7.string().min(1).optional(),
+import fs4 from "node:fs";
+import path7 from "node:path";
+import { z as z6 } from "zod";
+var stringMapSchema6 = z6.record(z6.string(), z6.string());
+var kiroEntrySchema = z6.object({
+  url: z6.string().min(1).optional(),
   headers: stringMapSchema6.optional(),
-  command: z7.string().min(1).optional(),
-  args: z7.array(z7.string()).optional(),
+  command: z6.string().min(1).optional(),
+  args: z6.array(z6.string()).optional(),
   env: stringMapSchema6.optional(),
-  cwd: z7.string().min(1).optional(),
-  disabled: z7.boolean().optional()
+  cwd: z6.string().min(1).optional(),
+  disabled: z6.boolean().optional()
 }).passthrough();
 
 class KiroAdapter {
   id = "kiro";
   detectConfigPath() {
-    return path9.join(homeDir(), ".kiro", "settings", "mcp.json");
+    return path7.join(homeDir(), ".kiro", "settings", "mcp.json");
   }
   supportsHttp() {
     return true;
@@ -1295,46 +1183,46 @@ class KiroAdapter {
     }
   }
   syncSkills(skills) {
-    const skillsDir = path9.join(homeDir(), ".kiro", "skills");
-    if (!fs7.existsSync(skillsDir)) {
-      fs7.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path7.join(homeDir(), ".kiro", "skills");
+    if (!fs4.existsSync(skillsDir)) {
+      fs4.mkdirSync(skillsDir, { recursive: true });
     }
-    const existingFiles = fs7.readdirSync(skillsDir);
+    const existingFiles = fs4.readdirSync(skillsDir);
     const managedIds = new Set(skills.map((s) => s.id));
     for (const file of existingFiles) {
       if (file.endsWith(".md")) {
-        const id = path9.basename(file, ".md");
+        const id = path7.basename(file, ".md");
         if (!managedIds.has(id)) {
-          fs7.unlinkSync(path9.join(skillsDir, file));
+          fs4.unlinkSync(path7.join(skillsDir, file));
         }
       }
     }
     for (const skill of skills) {
-      const targetPath = path9.join(skillsDir, `${skill.id}.md`);
-      fs7.writeFileSync(targetPath, skill.content, "utf-8");
+      const targetPath = path7.join(skillsDir, `${skill.id}.md`);
+      fs4.writeFileSync(targetPath, skill.content, "utf-8");
     }
   }
 }
 
 // src/adapters/opencode.ts
-import path10 from "node:path";
-import { z as z8 } from "zod";
-var stringMapSchema7 = z8.record(z8.string(), z8.string());
-var openCodeEntrySchema = z8.object({
-  type: z8.string().optional(),
-  url: z8.string().min(1).optional(),
+import path8 from "node:path";
+import { z as z7 } from "zod";
+var stringMapSchema7 = z7.record(z7.string(), z7.string());
+var openCodeEntrySchema = z7.object({
+  type: z7.string().optional(),
+  url: z7.string().min(1).optional(),
   headers: stringMapSchema7.optional(),
-  command: z8.string().min(1).optional(),
-  args: z8.array(z8.string()).optional(),
+  command: z7.string().min(1).optional(),
+  args: z7.array(z7.string()).optional(),
   env: stringMapSchema7.optional(),
-  cwd: z8.string().min(1).optional(),
-  enabled: z8.boolean().optional()
+  cwd: z7.string().min(1).optional(),
+  enabled: z7.boolean().optional()
 }).passthrough();
 
 class OpenCodeAdapter {
   id = "opencode";
   detectConfigPath() {
-    return path10.join(homeDir(), ".config", "opencode", "opencode.json");
+    return path8.join(homeDir(), ".config", "opencode", "opencode.json");
   }
   supportsHttp() {
     return true;
@@ -1437,24 +1325,30 @@ class OpenCodeAdapter {
 }
 
 // src/adapters/vscode.ts
-import path11 from "node:path";
-import { z as z9 } from "zod";
-var stringMapSchema8 = z9.record(z9.string(), z9.string());
-var vscodeEntrySchema = z9.object({
-  type: z9.string().optional(),
-  url: z9.string().min(1).optional(),
+import path9 from "node:path";
+import { z as z8 } from "zod";
+var stringMapSchema8 = z8.record(z8.string(), z8.string());
+var vscodeEntrySchema = z8.object({
+  type: z8.string().optional(),
+  url: z8.string().min(1).optional(),
   headers: stringMapSchema8.optional(),
-  command: z9.string().min(1).optional(),
-  args: z9.array(z9.string()).optional(),
+  command: z8.string().min(1).optional(),
+  args: z8.array(z8.string()).optional(),
   env: stringMapSchema8.optional(),
-  cwd: z9.string().min(1).optional(),
-  disabled: z9.boolean().optional()
+  cwd: z8.string().min(1).optional(),
+  disabled: z8.boolean().optional()
 }).passthrough();
 
 class VsCodeAdapter {
   id = "vscode";
   detectConfigPath() {
-    return path11.join(homeDir(), "Library", "Application Support", "Code", "User", "mcp.json");
+    if (process.platform === "linux") {
+      return path9.join(homeDir(), ".config", "Code", "User", "mcp.json");
+    }
+    if (process.platform === "win32") {
+      return path9.join(process.env.APPDATA ?? "", "Code", "User", "mcp.json");
+    }
+    return path9.join(homeDir(), "Library", "Application Support", "Code", "User", "mcp.json");
   }
   supportsHttp() {
     return true;
@@ -1560,24 +1454,24 @@ class VsCodeAdapter {
 }
 
 // src/adapters/qwen.ts
-import fs8 from "node:fs";
-import path12 from "node:path";
-import { z as z10 } from "zod";
-var stringMapSchema9 = z10.record(z10.string(), z10.string());
-var qwenEntrySchema = z10.object({
-  httpUrl: z10.string().min(1).optional(),
+import fs5 from "node:fs";
+import path10 from "node:path";
+import { z as z9 } from "zod";
+var stringMapSchema9 = z9.record(z9.string(), z9.string());
+var qwenEntrySchema = z9.object({
+  httpUrl: z9.string().min(1).optional(),
   headers: stringMapSchema9.optional(),
-  command: z10.string().min(1).optional(),
-  args: z10.array(z10.string()).optional(),
+  command: z9.string().min(1).optional(),
+  args: z9.array(z9.string()).optional(),
   env: stringMapSchema9.optional(),
-  cwd: z10.string().min(1).optional(),
-  disabled: z10.boolean().optional()
+  cwd: z9.string().min(1).optional(),
+  disabled: z9.boolean().optional()
 }).passthrough();
 
 class QwenAdapter {
   id = "qwen";
   detectConfigPath() {
-    return path12.join(homeDir(), ".qwen", "settings.json");
+    return path10.join(homeDir(), ".qwen", "settings.json");
   }
   supportsHttp() {
     return true;
@@ -1674,23 +1568,23 @@ class QwenAdapter {
     }
   }
   syncSkills(skills) {
-    const skillsDir = path12.join(homeDir(), ".qwen", "skills");
-    if (!fs8.existsSync(skillsDir)) {
-      fs8.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path10.join(homeDir(), ".qwen", "skills");
+    if (!fs5.existsSync(skillsDir)) {
+      fs5.mkdirSync(skillsDir, { recursive: true });
     }
-    const existingFiles = fs8.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 = path12.basename(file, ".md");
+        const id = path10.basename(file, ".md");
         if (!managedIds.has(id)) {
-          fs8.unlinkSync(path12.join(skillsDir, file));
+          fs5.unlinkSync(path10.join(skillsDir, file));
         }
       }
     }
     for (const skill of skills) {
-      const targetPath = path12.join(skillsDir, `${skill.id}.md`);
-      fs8.writeFileSync(targetPath, skill.content, "utf-8");
+      const targetPath = path10.join(skillsDir, `${skill.id}.md`);
+      fs5.writeFileSync(targetPath, skill.content, "utf-8");
     }
   }
 }
@@ -1967,9 +1861,9 @@ function maybePrefixBearer(target, value, raw = false) {
 var APP_VERSION = "0.1.3";
 
 // src/core/update.ts
-import fs9 from "node:fs";
-import path13 from "node:path";
-import { execFileSync as execFileSync3 } from "node:child_process";
+import fs6 from "node:fs";
+import path11 from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
 function compareVersions(a, b) {
   const partsA = a.split(".").map(Number);
   const partsB = b.split(".").map(Number);
@@ -1985,7 +1879,7 @@ function compareVersions(a, b) {
 }
 async function checkForUpdates() {
   try {
-    const output = execFileSync3("npm", ["view", "@kwonye/mcpx", "version"], {
+    const output = execFileSync2("npm", ["view", "@kwonye/mcpx", "version"], {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -2007,17 +1901,17 @@ async function checkForUpdates() {
 }
 function getStagedUpdate() {
   const stagedPath = getStagedVersionPath();
-  if (!fs9.existsSync(stagedPath)) {
+  if (!fs6.existsSync(stagedPath)) {
     return null;
   }
   try {
-    const raw = fs9.readFileSync(stagedPath, "utf8");
+    const raw = fs6.readFileSync(stagedPath, "utf8");
     const info = JSON.parse(raw);
     if (!info.version || !info.cliPath) {
       return null;
     }
-    const absoluteCliPath = path13.isAbsolute(info.cliPath) ? info.cliPath : path13.join(getUpdatesDir(), info.cliPath);
-    if (!fs9.existsSync(absoluteCliPath)) {
+    const absoluteCliPath = path11.isAbsolute(info.cliPath) ? info.cliPath : path11.join(getUpdatesDir(), info.cliPath);
+    if (!fs6.existsSync(absoluteCliPath)) {
       return null;
     }
     return {
@@ -2033,15 +1927,15 @@ function stageUpdate(version, cliPath) {
   ensureDir(updatesDir);
   const stagedInfo = {
     version,
-    cliPath: path13.isAbsolute(cliPath) ? path13.relative(updatesDir, cliPath) : cliPath,
+    cliPath: path11.isAbsolute(cliPath) ? path11.relative(updatesDir, cliPath) : cliPath,
     stagedAt: new Date().toISOString()
   };
-  fs9.writeFileSync(getStagedVersionPath(), JSON.stringify(stagedInfo, null, 2), "utf8");
+  fs6.writeFileSync(getStagedVersionPath(), JSON.stringify(stagedInfo, null, 2), "utf8");
 }
 function clearStagedUpdate() {
   const stagedPath = getStagedVersionPath();
-  if (fs9.existsSync(stagedPath)) {
-    fs9.unlinkSync(stagedPath);
+  if (fs6.existsSync(stagedPath)) {
+    fs6.unlinkSync(stagedPath);
   }
 }
 function getStagedCliPath() {
@@ -2050,31 +1944,31 @@ function getStagedCliPath() {
 }
 function removeOldVersions(keepCount = 2) {
   const updatesDir = getUpdatesDir();
-  if (!fs9.existsSync(updatesDir)) {
+  if (!fs6.existsSync(updatesDir)) {
     return;
   }
-  const entries = fs9.readdirSync(updatesDir, { withFileTypes: true });
+  const entries = fs6.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;
   }
   for (const oldVersion of versionDirs.slice(keepCount)) {
-    const oldPath = path13.join(updatesDir, oldVersion);
+    const oldPath = path11.join(updatesDir, oldVersion);
     try {
-      fs9.rmSync(oldPath, { recursive: true, force: true });
+      fs6.rmSync(oldPath, { recursive: true, force: true });
     } catch {}
   }
 }
 
 // src/core/update-manager.ts
-import fs10 from "node:fs";
-import path14 from "node:path";
+import fs7 from "node:fs";
+import path12 from "node:path";
 import { execSync, spawn } from "node:child_process";
 function acquireLock() {
   const lockPath = getUpdateLockPath();
   try {
-    ensureDir(path14.dirname(lockPath));
-    fs10.writeFileSync(lockPath, `${process.pid}
+    ensureDir(path12.dirname(lockPath));
+    fs7.writeFileSync(lockPath, `${process.pid}
 `, { flag: "wx" });
     return true;
   } catch {
@@ -2084,25 +1978,25 @@ function acquireLock() {
 function releaseLock() {
   const lockPath = getUpdateLockPath();
   try {
-    fs10.unlinkSync(lockPath);
+    fs7.unlinkSync(lockPath);
   } catch {}
 }
 function isUpdateInProgress() {
   const lockPath = getUpdateLockPath();
-  if (!fs10.existsSync(lockPath)) {
+  if (!fs7.existsSync(lockPath)) {
     return false;
   }
   try {
-    const raw = fs10.readFileSync(lockPath, "utf8").trim();
+    const raw = fs7.readFileSync(lockPath, "utf8").trim();
     const pid = Number(raw);
     if (!Number.isFinite(pid) || pid <= 0) {
-      fs10.unlinkSync(lockPath);
+      fs7.unlinkSync(lockPath);
       return false;
     }
     process.kill(pid, 0);
     return true;
   } catch {
-    fs10.unlinkSync(lockPath);
+    fs7.unlinkSync(lockPath);
     return false;
   }
 }
@@ -2113,8 +2007,8 @@ async function downloadAndStageUpdate() {
   }
   const targetVersion = updateStatus.latestVersion;
   const updatesDir = getUpdatesDir();
-  const versionDir = path14.join(updatesDir, `v${targetVersion}`);
-  if (fs10.existsSync(versionDir)) {
+  const versionDir = path12.join(updatesDir, `v${targetVersion}`);
+  if (fs7.existsSync(versionDir)) {
     const existingStaged = getStagedUpdate();
     if (existingStaged?.version === targetVersion) {
       return { success: false, error: `Version ${targetVersion} already staged` };
@@ -2126,8 +2020,8 @@ async function downloadAndStageUpdate() {
       cwd: versionDir,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    const tarballPath = path14.join(versionDir, `kwonye-mcpx-${targetVersion}.tgz`);
-    if (!fs10.existsSync(tarballPath)) {
+    const tarballPath = path12.join(versionDir, `kwonye-mcpx-${targetVersion}.tgz`);
+    if (!fs7.existsSync(tarballPath)) {
       throw new Error("Downloaded tarball not found");
     }
     execSync(`tar -xzf ${tarballPath} --strip-components=1`, {
@@ -2138,8 +2032,8 @@ async function downloadAndStageUpdate() {
       cwd: versionDir,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    const cliPath = path14.join(versionDir, "dist", "cli.js");
-    if (!fs10.existsSync(cliPath)) {
+    const cliPath = path12.join(versionDir, "dist", "cli.js");
+    if (!fs7.existsSync(cliPath)) {
       throw new Error("CLI entry point not found in downloaded package");
     }
     stageUpdate(targetVersion, cliPath);
@@ -2147,7 +2041,7 @@ async function downloadAndStageUpdate() {
     return { success: true, version: targetVersion };
   } catch (error) {
     try {
-      fs10.rmSync(versionDir, { recursive: true, force: true });
+      fs7.rmSync(versionDir, { recursive: true, force: true });
     } catch {}
     return {
       success: false,
@@ -2225,14 +2119,14 @@ function performRollback() {
 }
 
 // src/core/daemon.ts
-import fs11 from "node:fs";
+import fs8 from "node:fs";
 import net from "node:net";
 import { spawn as spawn2 } from "node:child_process";
 
 // src/gateway/server.ts
 import http from "node:http";
 import { URL } from "node:url";
-import crypto3 from "node:crypto";
+import crypto from "node:crypto";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import {
   StdioClientTransport,
@@ -2411,6 +2305,61 @@ async function callUpstream(upstream, method, params, id, secrets, runtime, pass
   }
   return callHttpUpstream(upstream, method, params, id, secrets, passthroughAuthorizationHeader);
 }
+async function getUpstreamTokenCounts(config, secrets, runtime) {
+  if (!runtime.tokenCache) {
+    runtime.tokenCache = new Map;
+  }
+  const results = {};
+  const upstreams = listUpstreams(config);
+  for (const upstream of upstreams) {
+    if (runtime.tokenCache.has(upstream.name)) {
+      results[upstream.name] = runtime.tokenCache.get(upstream.name);
+      continue;
+    }
+    try {
+      const prevTimeout = process.env.MCPX_UPSTREAM_TIMEOUT_MS;
+      process.env.MCPX_UPSTREAM_TIMEOUT_MS = "3000";
+      let toolsCount = 0;
+      let resourcesCount = 0;
+      let promptsCount = 0;
+      try {
+        const toolsResult = await callUpstream(upstream, "tools/list", {}, "token-tools", secrets, runtime);
+        if (toolsResult && toolsResult.tools) {
+          toolsCount = Math.ceil(JSON.stringify(toolsResult.tools).length / 4);
+        }
+      } catch (err) {}
+      try {
+        const resourcesResult = await callUpstream(upstream, "resources/list", {}, "token-resources", secrets, runtime);
+        if (resourcesResult && resourcesResult.resources) {
+          resourcesCount = Math.ceil(JSON.stringify(resourcesResult.resources).length / 4);
+        }
+      } catch (err) {}
+      try {
+        const promptsResult = await callUpstream(upstream, "prompts/list", {}, "token-prompts", secrets, runtime);
+        if (promptsResult && promptsResult.prompts) {
+          promptsCount = Math.ceil(JSON.stringify(promptsResult.prompts).length / 4);
+        }
+      } catch (err) {}
+      if (prevTimeout !== undefined) {
+        process.env.MCPX_UPSTREAM_TIMEOUT_MS = prevTimeout;
+      } else {
+        delete process.env.MCPX_UPSTREAM_TIMEOUT_MS;
+      }
+      const total = toolsCount + resourcesCount + promptsCount;
+      const countObj = {
+        tools: toolsCount,
+        resources: resourcesCount,
+        prompts: promptsCount,
+        total
+      };
+      runtime.tokenCache.set(upstream.name, countObj);
+      results[upstream.name] = countObj;
+    } catch (error) {
+      results[upstream.name] = { tools: 0, resources: 0, prompts: 0, total: 0 };
+    }
+  }
+  return results;
+}
 function getConfiguredTimeoutMs() {
   const configuredTimeout = Number(process.env.MCPX_UPSTREAM_TIMEOUT_MS ?? DEFAULT_UPSTREAM_TIMEOUT_MS);
   return Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? configuredTimeout : DEFAULT_UPSTREAM_TIMEOUT_MS;
@@ -2719,6 +2668,13 @@ async function handleListTools(config, secrets, runtime, upstreamFilter, clientA
   for (const upstream of upstreams) {
     try {
       const result = await callUpstream(upstream, "tools/list", {}, `list-tools-${upstream.name}`, secrets, runtime, clientAuthorizationHeader);
+      if (!runtime.tokenCache) {
+        runtime.tokenCache = new Map;
+      }
+      const existing = runtime.tokenCache.get(upstream.name) ?? { tools: 0, resources: 0, prompts: 0, total: 0 };
+      existing.tools = Math.ceil(JSON.stringify(result.tools ?? []).length / 4);
+      existing.total = existing.tools + existing.resources + existing.prompts;
+      runtime.tokenCache.set(upstream.name, existing);
       for (const tool of result.tools ?? []) {
         const name = typeof tool.name === "string" ? tool.name : "tool";
         tools.push({
@@ -2742,6 +2698,13 @@ async function handleListResources(config, secrets, runtime, upstreamFilter, cli
   for (const upstream of upstreams) {
     try {
       const result = await callUpstream(upstream, "resources/list", {}, `list-resources-${upstream.name}`, secrets, runtime, clientAuthorizationHeader);
+      if (!runtime.tokenCache) {
+        runtime.tokenCache = new Map;
+      }
+      const existing = runtime.tokenCache.get(upstream.name) ?? { tools: 0, resources: 0, prompts: 0, total: 0 };
+      existing.resources = Math.ceil(JSON.stringify(result.resources ?? []).length / 4);
+      existing.total = existing.tools + existing.resources + existing.prompts;
+      runtime.tokenCache.set(upstream.name, existing);
       for (const resource of result.resources ?? []) {
         const originalUri = typeof resource.uri === "string" ? resource.uri : "";
         const originalName = typeof resource.name === "string" ? resource.name : originalUri;
@@ -2767,6 +2730,13 @@ async function handleListPrompts(config, secrets, runtime, upstreamFilter, clien
   for (const upstream of upstreams) {
     try {
       const result = await callUpstream(upstream, "prompts/list", {}, `list-prompts-${upstream.name}`, secrets, runtime, clientAuthorizationHeader);
+      if (!runtime.tokenCache) {
+        runtime.tokenCache = new Map;
+      }
+      const existing = runtime.tokenCache.get(upstream.name) ?? { tools: 0, resources: 0, prompts: 0, total: 0 };
+      existing.prompts = Math.ceil(JSON.stringify(result.prompts ?? []).length / 4);
+      existing.total = existing.tools + existing.resources + existing.prompts;
+      runtime.tokenCache.set(upstream.name, existing);
       for (const prompt of result.prompts ?? []) {
         const name = typeof prompt.name === "string" ? prompt.name : "prompt";
         prompts.push({
@@ -2908,11 +2878,15 @@ async function handleRequestObject(request, secrets, runtime, upstreamFilter, cl
   if (request.method === "ping") {
     return makeResult(id, { ok: true });
   }
-  const config = loadConfig();
+  const config = loadMergedConfig();
   if (upstreamFilter && listUpstreams(config, upstreamFilter).length === 0) {
     return makeError(id, -32602, `Unknown upstream: ${upstreamFilter}`);
   }
   await reconcileStdioConnections(config, runtime);
+  if (request.method === "custom/tokenCounts") {
+    const result = await getUpstreamTokenCounts(config, secrets, runtime);
+    return makeResult(id, result);
+  }
   if (request.method === "tools/list") {
     const result = await handleListTools(config, secrets, runtime, upstreamFilter, clientAuthorizationHeader);
     return makeResult(id, result);
@@ -2942,7 +2916,7 @@ async function maybeHandleWellKnownOAuthRequest(request, response, requestUrl, s
     response.end(JSON.stringify({ error: "method_not_allowed" }));
     return true;
   }
-  const config = loadConfig();
+  const config = loadMergedConfig();
   const requestedUpstream = getRequestedUpstream(requestUrl);
   const upstream = getScopedHttpUpstream(config, requestedUpstream);
   if (!upstream) {
@@ -3115,7 +3089,7 @@ function createGatewayServer(options) {
         response.setHeader("content-type", "application/json");
       }
       if (hasInitialize) {
-        const sessionId = crypto3.randomUUID();
+        const sessionId = crypto.randomUUID();
         response.setHeader("mcp-session-id", sessionId);
         response.setHeader("MCP-Session-Id", sessionId);
       }
@@ -3171,10 +3145,10 @@ function createGatewayServer(options) {
 
 // src/core/daemon.ts
 function readPidFromFile(pidPath = getPidPath()) {
-  if (!fs11.existsSync(pidPath)) {
+  if (!fs8.existsSync(pidPath)) {
     return null;
   }
-  const raw = fs11.readFileSync(pidPath, "utf8").trim();
+  const raw = fs8.readFileSync(pidPath, "utf8").trim();
   if (!raw) {
     return null;
   }
@@ -3253,7 +3227,7 @@ async function startDaemon(config, cliPath, secrets) {
       };
     }
     try {
-      fs11.unlinkSync(getPidPath());
+      fs8.unlinkSync(getPidPath());
     } catch {}
   }
   const port = await resolveGatewayPort(config);
@@ -3262,7 +3236,7 @@ async function startDaemon(config, cliPath, secrets) {
   const logPath = getLogPath();
   ensureParentDir(pidPath);
   ensureParentDir(logPath);
-  const logFd = fs11.openSync(logPath, "a", 384);
+  const logFd = fs8.openSync(logPath, "a", 384);
   const child = spawn2(process.execPath, [cliPath, "daemon", "run", "--port", String(port)], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -3272,7 +3246,7 @@ async function startDaemon(config, cliPath, secrets) {
     }
   });
   child.unref();
-  fs11.writeFileSync(pidPath, `${child.pid}
+  fs8.writeFileSync(pidPath, `${child.pid}
 `, { mode: 384 });
   startBackgroundUpdateCheck();
   return {
@@ -3295,7 +3269,7 @@ function stopDaemon() {
     process.kill(pid, "SIGTERM");
   } catch {}
   try {
-    fs11.unlinkSync(pidPath);
+    fs8.unlinkSync(pidPath);
   } catch {}
   return {
     stopped: true,
@@ -3308,10 +3282,10 @@ async function restartDaemon(config, cliPath, secrets) {
 }
 function readDaemonLogs(maxLines = 200) {
   const logPath = getLogPath();
-  if (!fs11.existsSync(logPath)) {
+  if (!fs8.existsSync(logPath)) {
     return "";
   }
-  const lines = fs11.readFileSync(logPath, "utf8").split(`
+  const lines = fs8.readFileSync(logPath, "utf8").split(`
 `);
   return lines.slice(Math.max(lines.length - maxLines, 0)).join(`
 `);
@@ -3380,26 +3354,74 @@ function buildAuthBindings(spec) {
     secretName: secretRefName(binding.value) ?? undefined
   }));
 }
-function buildStatusReport(config, managedIndex, daemon = getDaemonStatus(config)) {
+async function fetchTokenCounts(gatewayUrl, token) {
+  try {
+    const res = await fetch(gatewayUrl, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: "status-tokens",
+        method: "custom/tokenCounts",
+        params: {}
+      })
+    });
+    if (!res.ok) {
+      return {};
+    }
+    const data = await res.json();
+    return data?.result ?? {};
+  } catch (error) {
+    return {};
+  }
+}
+async function buildStatusReport(config, managedIndex, daemon = getDaemonStatus(config)) {
+  const secrets = new SecretsManager;
+  const token = ensureGatewayToken(config, secrets);
+  const gatewayUrl = getGatewayUrl(config);
+  let tokenCounts = {};
+  if (daemon.running) {
+    tokenCounts = await fetchTokenCounts(gatewayUrl, token);
+  }
+  const projectEntries = Object.values(config.projects ?? {});
+  let totalGlobalTokens = 0;
+  const totalProjectTokens = {};
   const serverNames = Object.keys(config.servers).sort((left, right) => left.localeCompare(right));
   const servers = serverNames.map((name) => {
     const spec = config.servers[name];
-    return {
+    const tokenCount = tokenCounts[name];
+    const serverEntry = {
       name,
       enabled: isServerEnabled(spec),
       transport: spec.transport,
       target: describeServerTarget(spec),
       authBindings: buildAuthBindings(spec),
-      clients: buildClientMappings(config, managedIndex, name)
+      clients: buildClientMappings(config, managedIndex, name),
+      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;
+      }
+    }
+    return serverEntry;
   });
   return {
-    gatewayUrl: getGatewayUrl(config),
+    gatewayUrl,
     daemon,
     upstreamCount: servers.length,
     servers,
-    clients: config.clients
+    clients: config.clients,
+    projects: config.projects,
+    totalGlobalTokens,
+    totalProjectTokens
   };
 }
 
-export { getConfigPath, getManagedIndexPath, defaultConfig, loadConfig, saveConfig, addServer, removeServer, updateServer, setServerEnabled, ensureGatewayToken, listSkills, getSkill, saveSkill, deleteSkill, SecretsManager, readSecretValueFromStdin, probeHttpAuthRequirement, getAdapters, loadManagedIndex, getGatewayUrl, syncAllClients, toSecretRef, secretRefName, defaultAuthSecretName, resolveAuthTarget, applyAuthReference, removeAuthReference, listAuthBindings, maybePrefixBearer, APP_VERSION, compareVersions, checkForUpdates, getStagedUpdate, clearStagedUpdate, getStagedCliPath, startBackgroundUpdateCheck, runBackgroundUpdate, performUpdate, performRollback, getDaemonStatus, startDaemon, stopDaemon, restartDaemon, readDaemonLogs, runDaemonForeground, STATUS_CLIENTS, buildStatusReport };
+export { listSkills, getSkill, saveSkill, deleteSkill, probeHttpAuthRequirement, fetchRegistryServerDetail, selectBestPackage, extractRequiredInputs, mapRegistryToSpec, getAdapters, loadManagedIndex, getGatewayUrl, syncAllClients, toSecretRef, secretRefName, defaultAuthSecretName, resolveAuthTarget, applyAuthReference, removeAuthReference, listAuthBindings, maybePrefixBearer, APP_VERSION, compareVersions, checkForUpdates, getStagedUpdate, clearStagedUpdate, getStagedCliPath, startBackgroundUpdateCheck, runBackgroundUpdate, performUpdate, performRollback, getDaemonStatus, startDaemon, stopDaemon, restartDaemon, readDaemonLogs, runDaemonForeground, STATUS_CLIENTS, buildStatusReport };