@kwonye/mcpx 0.1.74 → 0.1.77

package/dist/{cli-33pamqwn.js → cli-f16kphtq.js}

@@ -1,328 +1,98 @@
 import {
-  isServerEnabled,
-  normalizeServerSpecEnabled
-} from "./cli-q8de7zb0.js";
+  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/paths.ts
-import os from "node:os";
-import path from "node:path";
+// src/core/skills.ts
 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 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);
-}
-
-// src/core/secrets.ts
-import { execFileSync } from "node:child_process";
-import crypto2 from "node:crypto";
-import fs3 from "node:fs";
-function parseSecretRef(ref) {
-  if (!ref.startsWith("secret://")) {
+import path from "node:path";
+function listSkills() {
+  const skillsDir = getSkillsDir();
+  if (!fs.existsSync(skillsDir)) {
+    return [];
+  }
+  const files = fs.readdirSync(skillsDir);
+  const skills = [];
+  for (const file of files) {
+    if (file.endsWith(".md")) {
+      const id = path.basename(file, ".md");
+      const content = fs.readFileSync(path.join(skillsDir, file), "utf-8");
+      skills.push({ id, content });
+    }
+  }
+  return skills;
+}
+function getSkill(id) {
+  const skillsDir = getSkillsDir();
+  const filePath = path.join(skillsDir, `${id}.md`);
+  if (!fs.existsSync(filePath)) {
     return null;
   }
-  const name = ref.slice("secret://".length);
-  return name.length > 0 ? name : null;
+  const content = fs.readFileSync(filePath, "utf-8");
+  return { id, content };
 }
-
-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 saveSkill(id, content) {
+  const skillsDir = getSkillsDir();
+  ensureDir(skillsDir);
+  const filePath = path.join(skillsDir, `${id}.md`);
+  fs.writeFileSync(filePath, content, "utf-8");
 }
-function readSecretValueFromStdin() {
-  if (process.stdin.isTTY) {
-    throw new Error("No value provided. Use --value or pipe a value via stdin.");
-  }
-  const content = fs3.readFileSync(process.stdin.fd, "utf8").trim();
-  if (content.length === 0) {
-    throw new Error("Empty secret value provided.");
+function deleteSkill(id) {
+  const skillsDir = getSkillsDir();
+  const filePath = path.join(skillsDir, `${id}.md`);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
   }
-  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",
@@ -356,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
@@ -371,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 path3 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) {
@@ -390,6 +299,11 @@ function pruneStaleManagedEntries(managedIndex, clientId, servers, keepEntryName
       delete servers[name];
     }
   }
+  for (const name of Object.keys(servers)) {
+    if (!keep.has(name) && name.endsWith(" (mcpx)")) {
+      delete servers[name];
+    }
+  }
 }
 function ensureManagedEntryWritable(managedIndex, clientId, entryName, existingValue) {
   if (existingValue === undefined || existingValue === null) {
@@ -496,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 path3.join(homeDir(), ".claude.json");
+    return path2.join(homeDir(), ".claude.json");
   }
   supportsHttp() {
     return true;
@@ -623,24 +537,40 @@ class ClaudeAdapter {
 }
 
 // src/adapters/claude-desktop.ts
-import path4 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 = execFileSync("which", ["mcpx"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (mcpxPath)
+      return { command: mcpxPath, args: ["proxy", upstreamName] };
+  } catch {}
+  return { command: "npx", args: ["-y", "@kwonye/mcpx@latest", "proxy", upstreamName] };
+}
 
 class ClaudeDesktopAdapter {
   id = "claude-desktop";
   detectConfigPath() {
-    return path4.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;
@@ -663,7 +593,7 @@ class ClaudeDesktopAdapter {
         continue;
       }
       const entry = parsed.data;
-      if ((entry.type === undefined || entry.type === "http") && entry.url && !entry.command) {
+      if ((entry.type === undefined || entry.type === "http" || entry.type === "streamable_http") && entry.url && !entry.command) {
         result.candidates.push({
           clientId: this.id,
           configPath,
@@ -707,11 +637,10 @@ class ClaudeDesktopAdapter {
     try {
       const raw = readJsonFile(configPath, {});
       const enabledEntries = options.managedEntries.filter((entry) => entry.enabled);
-      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => [entry.name, {
-        type: "http",
-        url: entry.url,
-        headers: entry.headers
-      }]));
+      const serverEntries = Object.fromEntries(enabledEntries.map((entry) => {
+        const { command, args } = buildProxyEntry(entry);
+        return [entry.name, { command, args }];
+      }));
       const enabledManagedNames = enabledEntries.map((entry) => entry.name);
       const topLevelServers = raw.mcpServers ?? {};
       removeSourceEntries(topLevelServers, options.sourceEntriesToRemove);
@@ -727,10 +656,10 @@ class ClaudeDesktopAdapter {
       }
       raw.mcpServers = topLevelServers;
       writeJsonAtomic(configPath, raw);
-      setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(options.managedEntries.map((entry) => [
-        entry.name,
-        JSON.stringify({ type: "http", url: entry.url, headers: entry.headers, enabled: entry.enabled })
-      ])));
+      setManagedEntries(options.managedIndex, this.id, configPath, Object.fromEntries(options.managedEntries.map((entry) => {
+        const { command, args } = buildProxyEntry(entry);
+        return [entry.name, JSON.stringify({ command, args, enabled: entry.enabled })];
+      })));
       return okResult(this.id, configPath);
     } catch (error) {
       return errorResult(this.id, configPath, error.message);
@@ -739,31 +668,31 @@ class ClaudeDesktopAdapter {
 }
 
 // src/adapters/codex.ts
-import path5 from "node:path";
-import fs4 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 path5.join(homeDir(), ".codex", "config.toml");
+    return path4.join(homeDir(), ".codex", "config.toml");
   }
   supportsHttp() {
     return true;
@@ -771,10 +700,10 @@ class CodexAdapter {
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
     const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs4.existsSync(configPath)) {
+    if (!configPath || !fs2.existsSync(configPath)) {
       return result;
     }
-    const existing = fs4.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)) {
@@ -829,7 +758,7 @@ class CodexAdapter {
       return errorResult(this.id, undefined, "Unable to resolve Codex config.toml path.");
     }
     try {
-      const existing = fs4.existsSync(configPath) ? fs4.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);
@@ -850,10 +779,10 @@ class CodexAdapter {
         mcpServers[name] = entry;
       }
       doc.mcp_servers = mcpServers;
-      fs4.mkdirSync(path5.dirname(configPath), { recursive: true });
+      fs2.mkdirSync(path4.dirname(configPath), { recursive: true });
       const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
-      fs4.writeFileSync(tmpPath, stringify(doc), { mode: 384 });
-      fs4.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) {
@@ -863,24 +792,30 @@ class CodexAdapter {
 }
 
 // src/adapters/cursor.ts
-import path6 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 path6.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;
@@ -986,24 +921,36 @@ class CursorAdapter {
 }
 
 // src/adapters/cline.ts
-import path7 from "node:path";
-import fs5 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 [
-    path7.join(homeDir(), "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
-    path7.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")
   ];
 }
 
@@ -1012,7 +959,7 @@ class ClineAdapter {
   detectConfigPath() {
     const candidates = getCandidatePaths();
     for (const candidate of candidates) {
-      if (fs5.existsSync(candidate)) {
+      if (fs3.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -1024,7 +971,7 @@ class ClineAdapter {
   scanForImports(_config, managedIndex) {
     const configPath = this.detectConfigPath();
     const result = emptyImportScan(this.id, configPath ?? undefined);
-    if (!configPath || !fs5.existsSync(configPath)) {
+    if (!configPath || !fs3.existsSync(configPath)) {
       return result;
     }
     const raw = readJsonFile(configPath, {});
@@ -1119,23 +1066,24 @@ class ClineAdapter {
 }
 
 // src/adapters/kiro.ts
-import path8 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 path8.join(homeDir(), ".kiro", "settings", "mcp.json");
+    return path7.join(homeDir(), ".kiro", "settings", "mcp.json");
   }
   supportsHttp() {
     return true;
@@ -1234,27 +1182,47 @@ class KiroAdapter {
       return errorResult(this.id, configPath, error.message);
     }
   }
+  syncSkills(skills) {
+    const skillsDir = path7.join(homeDir(), ".kiro", "skills");
+    if (!fs4.existsSync(skillsDir)) {
+      fs4.mkdirSync(skillsDir, { recursive: true });
+    }
+    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 = path7.basename(file, ".md");
+        if (!managedIds.has(id)) {
+          fs4.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");
+    }
+  }
 }
 
 // src/adapters/opencode.ts
-import path9 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 path9.join(homeDir(), ".config", "opencode", "opencode.json");
+    return path8.join(homeDir(), ".config", "opencode", "opencode.json");
   }
   supportsHttp() {
     return true;
@@ -1357,24 +1325,30 @@ class OpenCodeAdapter {
 }
 
 // src/adapters/vscode.ts
-import path10 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 path10.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;
@@ -1480,23 +1454,24 @@ class VsCodeAdapter {
 }
 
 // src/adapters/qwen.ts
-import path11 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 path11.join(homeDir(), ".qwen", "settings.json");
+    return path10.join(homeDir(), ".qwen", "settings.json");
   }
   supportsHttp() {
     return true;
@@ -1592,6 +1567,26 @@ class QwenAdapter {
       return errorResult(this.id, configPath, error.message);
     }
   }
+  syncSkills(skills) {
+    const skillsDir = path10.join(homeDir(), ".qwen", "skills");
+    if (!fs5.existsSync(skillsDir)) {
+      fs5.mkdirSync(skillsDir, { recursive: true });
+    }
+    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 = path10.basename(file, ".md");
+        if (!managedIds.has(id)) {
+          fs5.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");
+    }
+  }
 }
 
 // src/adapters/index.ts
@@ -1710,8 +1705,14 @@ function syncAllClients(config, secrets, targetClients) {
   const localToken = ensureGatewayToken(config, secrets);
   const gatewayUrl = getGatewayUrl(config);
   const managedEntries = buildManagedEntries(config, gatewayUrl, localToken);
+  const skills = listSkills();
   const results = [];
   for (const adapter of filteredAdapters) {
+    if (adapter.syncSkills) {
+      try {
+        adapter.syncSkills(skills);
+      } catch (error) {}
+    }
     if (!adapter.supportsHttp()) {
       results.push({
         clientId: adapter.id,
@@ -1857,11 +1858,11 @@ function maybePrefixBearer(target, value, raw = false) {
 }
 
 // src/version.ts
-var APP_VERSION = "0.1.74";
+var APP_VERSION = "0.1.77";
 
 // src/core/update.ts
 import fs6 from "node:fs";
-import path12 from "node:path";
+import path11 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 function compareVersions(a, b) {
   const partsA = a.split(".").map(Number);
@@ -1909,7 +1910,7 @@ function getStagedUpdate() {
     if (!info.version || !info.cliPath) {
       return null;
     }
-    const absoluteCliPath = path12.isAbsolute(info.cliPath) ? info.cliPath : path12.join(getUpdatesDir(), info.cliPath);
+    const absoluteCliPath = path11.isAbsolute(info.cliPath) ? info.cliPath : path11.join(getUpdatesDir(), info.cliPath);
     if (!fs6.existsSync(absoluteCliPath)) {
       return null;
     }
@@ -1926,7 +1927,7 @@ function stageUpdate(version, cliPath) {
   ensureDir(updatesDir);
   const stagedInfo = {
     version,
-    cliPath: path12.isAbsolute(cliPath) ? path12.relative(updatesDir, cliPath) : cliPath,
+    cliPath: path11.isAbsolute(cliPath) ? path11.relative(updatesDir, cliPath) : cliPath,
     stagedAt: new Date().toISOString()
   };
   fs6.writeFileSync(getStagedVersionPath(), JSON.stringify(stagedInfo, null, 2), "utf8");
@@ -1952,7 +1953,7 @@ function removeOldVersions(keepCount = 2) {
     return;
   }
   for (const oldVersion of versionDirs.slice(keepCount)) {
-    const oldPath = path12.join(updatesDir, oldVersion);
+    const oldPath = path11.join(updatesDir, oldVersion);
     try {
       fs6.rmSync(oldPath, { recursive: true, force: true });
     } catch {}
@@ -1961,12 +1962,12 @@ function removeOldVersions(keepCount = 2) {
 
 // src/core/update-manager.ts
 import fs7 from "node:fs";
-import path13 from "node:path";
+import path12 from "node:path";
 import { execSync, spawn } from "node:child_process";
 function acquireLock() {
   const lockPath = getUpdateLockPath();
   try {
-    ensureDir(path13.dirname(lockPath));
+    ensureDir(path12.dirname(lockPath));
     fs7.writeFileSync(lockPath, `${process.pid}
 `, { flag: "wx" });
     return true;
@@ -2006,7 +2007,7 @@ async function downloadAndStageUpdate() {
   }
   const targetVersion = updateStatus.latestVersion;
   const updatesDir = getUpdatesDir();
-  const versionDir = path13.join(updatesDir, `v${targetVersion}`);
+  const versionDir = path12.join(updatesDir, `v${targetVersion}`);
   if (fs7.existsSync(versionDir)) {
     const existingStaged = getStagedUpdate();
     if (existingStaged?.version === targetVersion) {
@@ -2019,7 +2020,7 @@ async function downloadAndStageUpdate() {
       cwd: versionDir,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    const tarballPath = path13.join(versionDir, `kwonye-mcpx-${targetVersion}.tgz`);
+    const tarballPath = path12.join(versionDir, `kwonye-mcpx-${targetVersion}.tgz`);
     if (!fs7.existsSync(tarballPath)) {
       throw new Error("Downloaded tarball not found");
     }
@@ -2031,7 +2032,7 @@ async function downloadAndStageUpdate() {
       cwd: versionDir,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    const cliPath = path13.join(versionDir, "dist", "cli.js");
+    const cliPath = path12.join(versionDir, "dist", "cli.js");
     if (!fs7.existsSync(cliPath)) {
       throw new Error("CLI entry point not found in downloaded package");
     }
@@ -2125,7 +2126,7 @@ 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,
@@ -2304,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;
@@ -2612,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({
@@ -2635,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;
@@ -2660,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({
@@ -2801,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);
@@ -2835,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) {
@@ -3008,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);
       }
@@ -3136,12 +3217,18 @@ function getDaemonStatus(config) {
 async function startDaemon(config, cliPath, secrets) {
   const existingStatus = getDaemonStatus(config);
   if (existingStatus.running && existingStatus.pid) {
-    return {
-      started: false,
-      pid: existingStatus.pid,
-      port: config.gateway.port,
-      message: "mcpx daemon already running."
-    };
+    const portAvailable = await isPortAvailable(config.gateway.port);
+    if (!portAvailable) {
+      return {
+        started: false,
+        pid: existingStatus.pid,
+        port: config.gateway.port,
+        message: "mcpx daemon already running."
+      };
+    }
+    try {
+      fs8.unlinkSync(getPidPath());
+    } catch {}
   }
   const port = await resolveGatewayPort(config);
   ensureGatewayToken(config, secrets);
@@ -3267,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, 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 };