@kwonye/mcpx 0.1.94 → 0.1.96

package/dist/{cli-154shqmt.js → cli-ap2jhwnz.js}

@@ -1,22 +1,27 @@
 import {
+  APP_VERSION,
   getGatewayUrl,
   persistSyncState,
   syncAllClients
-} from "./cli-n8vt375e.js";
+} from "./cli-2vg0te30.js";
 import {
   loadConfig,
   loadMergedConfig,
-  saveConfig
-} from "./cli-csfsg1yf.js";
+  loadProjectConfig,
+  saveConfig,
+  saveProjectConfig
+} from "./cli-v27bt25d.js";
 import {
   SecretsManager,
   UpstreamError,
   classifyUpstreamError,
   ensureGatewayToken
-} from "./cli-tk8bggg5.js";
+} from "./cli-remv48t3.js";
 import {
   ensureDir,
   ensureParentDir,
+  findProjectConfigPath,
+  getConfigPath,
   getLogPath,
   getPidPath,
   getStagedVersionPath,
@@ -27,6 +32,114 @@ import {
   isServerEnabled
 } from "./cli-s4gspqdf.js";
 
+// src/core/config-store.ts
+import fs from "node:fs";
+import path from "node:path";
+var LOCK_STALE_MS = 5000;
+var LOCK_RETRY_MS = 50;
+var LOCK_MAX_RETRIES = 40;
+var inProcessQueues = new Map;
+function getLockPath(filePath) {
+  return `${filePath}.lock`;
+}
+function acquireLock(filePath) {
+  const lockPath = getLockPath(filePath);
+  try {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const fd = fs.openSync(lockPath, "wx");
+    fs.writeSync(fd, String(process.pid));
+    fs.closeSync(fd);
+    return true;
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return false;
+    }
+    try {
+      const stat = fs.statSync(lockPath);
+      if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+        fs.unlinkSync(lockPath);
+        return acquireLock(filePath);
+      }
+    } catch {
+      return acquireLock(filePath);
+    }
+    return false;
+  }
+}
+function releaseLock(filePath) {
+  try {
+    fs.unlinkSync(getLockPath(filePath));
+  } catch {}
+}
+function mutateFile(filePath, load, save, fn) {
+  const prevQueue = inProcessQueues.get(filePath) ?? Promise.resolve();
+  const nextQueue = prevQueue.then(() => executeWithLock(filePath, load, save, fn), () => executeWithLock(filePath, load, save, fn));
+  inProcessQueues.set(filePath, nextQueue.catch(() => {
+    return;
+  }));
+  return nextQueue;
+}
+async function executeWithLock(filePath, load, save, fn) {
+  let acquired = false;
+  for (let attempt = 0;attempt < LOCK_MAX_RETRIES; attempt++) {
+    acquired = acquireLock(filePath);
+    if (acquired)
+      break;
+    await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+  }
+  if (!acquired) {
+    throw new Error(`Could not acquire lock for ${filePath}.`);
+  }
+  try {
+    const data = load(filePath);
+    const result = await fn(data);
+    save(data, filePath);
+    return result;
+  } finally {
+    releaseLock(filePath);
+  }
+}
+function mutateConfig(fn, configPath) {
+  return mutateFile(configPath ?? getConfigPath(), loadConfig, saveConfig, fn);
+}
+function mutateProjectConfig(projectConfigPath, fn) {
+  return mutateFile(projectConfigPath, (p) => loadProjectConfig(p), saveProjectConfig, fn);
+}
+async function mutateActiveConfig(options, mutator) {
+  const globalPath = getConfigPath();
+  if (!options.global) {
+    const projectConfigPath = findProjectConfigPath();
+    if (options.local) {
+      const projectPath = projectConfigPath ? path.dirname(projectConfigPath) : process.cwd();
+      const localPath = path.join(projectPath, ".mcpx.json");
+      const globalConfig = loadConfig(globalPath);
+      const result2 = await mutateProjectConfig(localPath, async (projectConfig) => {
+        const mergedConfig = {
+          ...globalConfig,
+          servers: { ...globalConfig.servers, ...projectConfig.servers }
+        };
+        const mutatorResult = await mutator(mergedConfig, { type: "project", projectPath });
+        const localServers = {};
+        for (const [name, spec] of Object.entries(mergedConfig.servers)) {
+          if (!(name in globalConfig.servers)) {
+            localServers[name] = spec;
+          }
+        }
+        projectConfig.servers = localServers;
+        return mutatorResult;
+      });
+      return { type: "project", configPath: localPath, projectPath, result: result2 };
+    }
+    if (projectConfigPath) {
+      const projectPath = path.dirname(projectConfigPath);
+      const result2 = await mutateConfig((config) => mutator(config, { type: "project", projectPath }), globalPath);
+      return { type: "project", configPath: globalPath, projectPath, result: result2 };
+    }
+  }
+  const result = await mutateConfig((config) => mutator(config, { type: "global" }), globalPath);
+  return { type: "global", configPath: globalPath, result };
+}
+
 // src/core/auth-probe.ts
 var JSON_RPC_VERSION = "2.0";
 var DEFAULT_AUTH_PROBE_TIMEOUT_MS = 8000;
@@ -363,20 +476,20 @@ function maybePrefixBearer(target, value, raw = false) {
 
 // src/core/spawn-env.ts
 import os from "node:os";
-import path from "node:path";
-import fs from "node:fs";
+import path2 from "node:path";
+import fs2 from "node:fs";
 function existingNvmCurrentBin() {
-  const nvmDir = process.env.NVM_DIR ?? path.join(os.homedir(), ".nvm");
-  const current = path.join(nvmDir, "current", "bin");
-  return fs.existsSync(current) ? current : null;
+  const nvmDir = process.env.NVM_DIR ?? path2.join(os.homedir(), ".nvm");
+  const current = path2.join(nvmDir, "current", "bin");
+  return fs2.existsSync(current) ? current : null;
 }
 function buildEnrichedPath(current = process.env.PATH ?? "") {
   const candidates = [
     ...current.split(":"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    path.join(os.homedir(), ".bun", "bin"),
-    path.join(os.homedir(), ".local", "bin"),
+    path2.join(os.homedir(), ".bun", "bin"),
+    path2.join(os.homedir(), ".local", "bin"),
     existingNvmCurrentBin()
   ].filter((entry) => Boolean(entry));
   const seen = new Set;
@@ -653,12 +766,14 @@ async function runOAuthLogin(serverName, spec, secrets, openUrl, configPath, cod
     const summary = syncAllClients(config, secrets);
     persistSyncState(summary, config);
     saveConfig(config, configPath);
+    new McpxOAuthProvider(serverName, secrets).invalidateCredentials("verifier");
     return { serverName, authorized: true };
   } catch (error) {
     if (backupTokens)
       secrets.setSecret(oauthName, backupTokens);
     if (backupClient)
       secrets.setSecret(clientName, backupClient);
+    new McpxOAuthProvider(serverName, secrets).invalidateCredentials("verifier");
     throw error;
   } finally {
     if (callbackServer) {
@@ -717,12 +832,9 @@ async function getOAuthAccessToken(serverName, spec, secrets, options = {}) {
   return stored.tokens.access_token;
 }
 
-// src/version.ts
-var APP_VERSION = "0.1.3";
-
 // src/core/update.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 import { execFileSync } from "node:child_process";
 function compareVersions(a, b) {
   const partsA = a.split(".").map(Number);
@@ -761,17 +873,17 @@ async function checkForUpdates() {
 }
 function getStagedUpdate() {
   const stagedPath = getStagedVersionPath();
-  if (!fs2.existsSync(stagedPath)) {
+  if (!fs3.existsSync(stagedPath)) {
     return null;
   }
   try {
-    const raw = fs2.readFileSync(stagedPath, "utf8");
+    const raw = fs3.readFileSync(stagedPath, "utf8");
     const info = JSON.parse(raw);
     if (!info.version || !info.cliPath) {
       return null;
     }
-    const absoluteCliPath = path2.isAbsolute(info.cliPath) ? info.cliPath : path2.join(getUpdatesDir(), info.cliPath);
-    if (!fs2.existsSync(absoluteCliPath)) {
+    const absoluteCliPath = path3.isAbsolute(info.cliPath) ? info.cliPath : path3.join(getUpdatesDir(), info.cliPath);
+    if (!fs3.existsSync(absoluteCliPath)) {
       return null;
     }
     return {
@@ -787,18 +899,18 @@ function stageUpdate(version, cliPath) {
   ensureDir(updatesDir);
   const stagedInfo = {
     version,
-    cliPath: path2.isAbsolute(cliPath) ? path2.relative(updatesDir, cliPath) : cliPath,
+    cliPath: path3.isAbsolute(cliPath) ? path3.relative(updatesDir, cliPath) : cliPath,
     stagedAt: new Date().toISOString()
   };
-  fs2.writeFileSync(getStagedVersionPath(), JSON.stringify(stagedInfo, null, 2), "utf8");
+  fs3.writeFileSync(getStagedVersionPath(), JSON.stringify(stagedInfo, null, 2), "utf8");
 }
 function shouldUseStagedCli(stagedVersion, currentVersion) {
   return compareVersions(stagedVersion, currentVersion) > 0;
 }
 function clearStagedUpdate() {
   const stagedPath = getStagedVersionPath();
-  if (fs2.existsSync(stagedPath)) {
-    fs2.unlinkSync(stagedPath);
+  if (fs3.existsSync(stagedPath)) {
+    fs3.unlinkSync(stagedPath);
   }
 }
 function getStagedCliPath() {
@@ -807,59 +919,59 @@ function getStagedCliPath() {
 }
 function removeOldVersions(keepCount = 2) {
   const updatesDir = getUpdatesDir();
-  if (!fs2.existsSync(updatesDir)) {
+  if (!fs3.existsSync(updatesDir)) {
     return;
   }
-  const entries = fs2.readdirSync(updatesDir, { withFileTypes: true });
+  const entries = fs3.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 = path2.join(updatesDir, oldVersion);
+    const oldPath = path3.join(updatesDir, oldVersion);
     try {
-      fs2.rmSync(oldPath, { recursive: true, force: true });
+      fs3.rmSync(oldPath, { recursive: true, force: true });
     } catch {}
   }
 }
 
 // src/core/update-manager.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 import { execSync, spawn } from "node:child_process";
-function acquireLock() {
+function acquireLock2() {
   const lockPath = getUpdateLockPath();
   try {
-    ensureDir(path3.dirname(lockPath));
-    fs3.writeFileSync(lockPath, `${process.pid}
+    ensureDir(path4.dirname(lockPath));
+    fs4.writeFileSync(lockPath, `${process.pid}
 `, { flag: "wx" });
     return true;
   } catch {
     return false;
   }
 }
-function releaseLock() {
+function releaseLock2() {
   const lockPath = getUpdateLockPath();
   try {
-    fs3.unlinkSync(lockPath);
+    fs4.unlinkSync(lockPath);
   } catch {}
 }
 function isUpdateInProgress() {
   const lockPath = getUpdateLockPath();
-  if (!fs3.existsSync(lockPath)) {
+  if (!fs4.existsSync(lockPath)) {
     return false;
   }
   try {
-    const raw = fs3.readFileSync(lockPath, "utf8").trim();
+    const raw = fs4.readFileSync(lockPath, "utf8").trim();
     const pid = Number(raw);
     if (!Number.isFinite(pid) || pid <= 0) {
-      fs3.unlinkSync(lockPath);
+      fs4.unlinkSync(lockPath);
       return false;
     }
     process.kill(pid, 0);
     return true;
   } catch {
-    fs3.unlinkSync(lockPath);
+    fs4.unlinkSync(lockPath);
     return false;
   }
 }
@@ -870,8 +982,8 @@ async function downloadAndStageUpdate() {
   }
   const targetVersion = updateStatus.latestVersion;
   const updatesDir = getUpdatesDir();
-  const versionDir = path3.join(updatesDir, `v${targetVersion}`);
-  if (fs3.existsSync(versionDir)) {
+  const versionDir = path4.join(updatesDir, `v${targetVersion}`);
+  if (fs4.existsSync(versionDir)) {
     const existingStaged = getStagedUpdate();
     if (existingStaged?.version === targetVersion) {
       return { success: false, error: `Version ${targetVersion} already staged` };
@@ -883,8 +995,8 @@ async function downloadAndStageUpdate() {
       cwd: versionDir,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    const tarballPath = path3.join(versionDir, `kwonye-mcpx-${targetVersion}.tgz`);
-    if (!fs3.existsSync(tarballPath)) {
+    const tarballPath = path4.join(versionDir, `kwonye-mcpx-${targetVersion}.tgz`);
+    if (!fs4.existsSync(tarballPath)) {
       throw new Error("Downloaded tarball not found");
     }
     execSync(`tar -xzf ${tarballPath} --strip-components=1`, {
@@ -895,16 +1007,24 @@ async function downloadAndStageUpdate() {
       cwd: versionDir,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    const cliPath = path3.join(versionDir, "dist", "cli.js");
-    if (!fs3.existsSync(cliPath)) {
+    const cliPath = path4.join(versionDir, "dist", "cli.js");
+    if (!fs4.existsSync(cliPath)) {
       throw new Error("CLI entry point not found in downloaded package");
     }
+    try {
+      execSync(`${process.execPath} ${JSON.stringify(cliPath)} --version`, {
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 1e4
+      });
+    } catch (smokeTestError) {
+      throw new Error(`Downloaded CLI failed smoke test (--version): ${smokeTestError instanceof Error ? smokeTestError.message : String(smokeTestError)}`);
+    }
     stageUpdate(targetVersion, cliPath);
     removeOldVersions(2);
     return { success: true, version: targetVersion };
   } catch (error) {
     try {
-      fs3.rmSync(versionDir, { recursive: true, force: true });
+      fs4.rmSync(versionDir, { recursive: true, force: true });
     } catch {}
     return {
       success: false,
@@ -913,10 +1033,13 @@ async function downloadAndStageUpdate() {
   }
 }
 function startBackgroundUpdateCheck() {
+  if (process.env.MCPX_NO_UPDATE === "1") {
+    return;
+  }
   if (isUpdateInProgress()) {
     return;
   }
-  if (!acquireLock()) {
+  if (!acquireLock2()) {
     return;
   }
   const child = spawn(process.execPath, [
@@ -933,7 +1056,7 @@ function startBackgroundUpdateCheck() {
   });
   child.unref();
   setTimeout(() => {
-    releaseLock();
+    releaseLock2();
   }, 60000);
 }
 async function runBackgroundUpdate() {
@@ -947,27 +1070,34 @@ async function runBackgroundUpdate() {
   } catch (error) {
     console.error(`[update-manager] Background update failed: ${error instanceof Error ? error.message : String(error)}`);
   } finally {
-    releaseLock();
+    releaseLock2();
   }
 }
 async function performUpdate() {
   if (isUpdateInProgress()) {
     return { success: false, message: "Another update is already in progress." };
   }
-  const result = await downloadAndStageUpdate();
-  if (result.success && result.version) {
+  if (!acquireLock2()) {
+    return { success: false, message: "Another update is already in progress." };
+  }
+  try {
+    const result = await downloadAndStageUpdate();
+    if (result.success && result.version) {
+      return {
+        success: true,
+        message: `Update to v${result.version} ready! Will activate on next run.`
+      };
+    }
+    if (result.error === "No update available") {
+      return { success: true, message: "Already on latest version." };
+    }
     return {
-      success: true,
-      message: `Update to v${result.version} ready! Will activate on next run.`
+      success: false,
+      message: result.error ?? "Update failed"
     };
+  } finally {
+    releaseLock2();
   }
-  if (result.error === "No update available") {
-    return { success: true, message: "Already on latest version." };
-  }
-  return {
-    success: false,
-    message: result.error ?? "Update failed"
-  };
 }
 function performRollback() {
   const currentStaged = getStagedUpdate();
@@ -982,7 +1112,7 @@ function performRollback() {
 }
 
 // src/core/daemon.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import net from "node:net";
 import { spawn as spawn2, execFileSync as execFileSync2 } from "node:child_process";
 
@@ -1226,11 +1356,41 @@ function withTimeout(work, timeoutMs, timeoutMessage) {
     });
   });
 }
-function specFingerprint(spec) {
-  return JSON.stringify(spec);
+function specFingerprint(spec, secrets) {
+  if (!secrets)
+    return JSON.stringify(spec);
+  const resolvedMarkers = {};
+  const collect = (obj) => {
+    if (!obj)
+      return;
+    for (const [key, value] of Object.entries(obj)) {
+      if (value.startsWith("secret://") || value.startsWith("oauth://")) {
+        try {
+          resolvedMarkers[key] = secrets.resolveMaybeSecret(value);
+        } catch {
+          resolvedMarkers[key] = value;
+        }
+      }
+    }
+  };
+  if (spec.transport === "stdio")
+    collect(spec.env);
+  if (spec.transport === "http")
+    collect(spec.headers);
+  return JSON.stringify({ spec, resolvedMarkers });
 }
+var EXTRA_INHERITED_ENV = ["TMPDIR", "LANG"];
 function resolveStdioEnv(spec, secrets) {
   const env = getDefaultEnvironment();
+  for (const key of EXTRA_INHERITED_ENV) {
+    const value = process.env[key];
+    if (value)
+      env[key] = value;
+  }
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith("LC_") && value)
+      env[key] = value;
+  }
   env.PATH = buildEnrichedPath(env.PATH);
   for (const [key, value] of Object.entries(spec.env ?? {})) {
     env[key] = secrets.resolveMaybeSecret(value);
@@ -1440,7 +1600,11 @@ async function handleListTools(config, secrets, runtime, upstreamFilter, clientA
       runtime.upstreamErrors?.set(upstream.name, { code, message: error instanceof Error ? error.message : String(error) });
     }
   }
-  return { tools };
+  const failedUpstreams = upstreams.filter((u) => runtime.upstreamErrors?.has(u.name)).map((u) => ({ name: u.name, ...runtime.upstreamErrors.get(u.name) }));
+  return {
+    tools,
+    ...failedUpstreams.length > 0 ? { _meta: { mcpxUpstreamErrors: failedUpstreams } } : {}
+  };
 }
 async function handleListResources(config, secrets, runtime, upstreamFilter, clientAuthorizationHeader) {
   const resources = [];
@@ -1476,7 +1640,11 @@ async function handleListResources(config, secrets, runtime, upstreamFilter, cli
       runtime.upstreamErrors?.set(upstream.name, { code, message: error instanceof Error ? error.message : String(error) });
     }
   }
-  return { resources };
+  const failedUpstreams = upstreams.filter((u) => runtime.upstreamErrors?.has(u.name)).map((u) => ({ name: u.name, ...runtime.upstreamErrors.get(u.name) }));
+  return {
+    resources,
+    ...failedUpstreams.length > 0 ? { _meta: { mcpxUpstreamErrors: failedUpstreams } } : {}
+  };
 }
 async function handleListPrompts(config, secrets, runtime, upstreamFilter, clientAuthorizationHeader) {
   const prompts = [];
@@ -1510,7 +1678,11 @@ async function handleListPrompts(config, secrets, runtime, upstreamFilter, clien
       runtime.upstreamErrors?.set(upstream.name, { code, message: error instanceof Error ? error.message : String(error) });
     }
   }
-  return { prompts };
+  const failedUpstreams = upstreams.filter((u) => runtime.upstreamErrors?.has(u.name)).map((u) => ({ name: u.name, ...runtime.upstreamErrors.get(u.name) }));
+  return {
+    prompts,
+    ...failedUpstreams.length > 0 ? { _meta: { mcpxUpstreamErrors: failedUpstreams } } : {}
+  };
 }
 async function routeNamespacedCall(config, method, params, id, secrets, runtime, upstreamFilter, clientAuthorizationHeader) {
   if (!params || typeof params !== "object") {
@@ -1784,6 +1956,16 @@ function createGatewayServer(options) {
           }
           return;
         }
+        const wantsStream = (request.headers.accept ?? "").includes("text/event-stream");
+        if (wantsStream && request.headers["mcp-session-id"]) {
+          response.statusCode = 405;
+          response.setHeader("content-type", "application/json");
+          response.end(JSON.stringify({ error: "get_stream_not_supported", message: "mcpx does not support server-initiated SSE streams over GET; use POST for all requests." }));
+          if (debug) {
+            console.error(`[mcpx gateway] -> 405 (GET stream not supported)`);
+          }
+          return;
+        }
         response.statusCode = 200;
         response.setHeader("content-type", "application/json");
         response.end(JSON.stringify({ ok: true, server: "mcpx" }));
@@ -1923,19 +2105,24 @@ function createGatewayServer(options) {
 }
 
 // src/core/daemon.ts
-function readPidFromFile(pidPath = getPidPath()) {
-  if (!fs4.existsSync(pidPath)) {
+function readPidRecordFromFile(pidPath = getPidPath()) {
+  if (!fs5.existsSync(pidPath)) {
     return null;
   }
-  const raw = fs4.readFileSync(pidPath, "utf8").trim();
+  const raw = fs5.readFileSync(pidPath, "utf8").trim();
   if (!raw) {
     return null;
   }
-  const pid = Number(raw);
+  const [pidRaw, portRaw] = raw.split(":");
+  const pid = Number(pidRaw);
   if (!Number.isFinite(pid) || pid <= 0) {
     return null;
   }
-  return pid;
+  const port = portRaw ? Number(portRaw) : null;
+  return { pid, port: Number.isFinite(port) && port > 0 ? port : null };
+}
+function readPidFromFile(pidPath = getPidPath()) {
+  return readPidRecordFromFile(pidPath)?.pid ?? null;
 }
 function processExists(pid) {
   try {
@@ -1959,7 +2146,7 @@ async function isPortAvailable(port) {
 }
 async function resolveGatewayPort(config, secrets) {
   if (await isPortAvailable(config.gateway.port)) {
-    return config.gateway.port;
+    return { port: config.gateway.port };
   }
   for (let offset = 1;offset <= 20; offset += 1) {
     const candidate = config.gateway.port + offset;
@@ -1977,7 +2164,7 @@ async function resolveGatewayPort(config, secrets) {
           saveConfig(config);
         } catch {}
       }
-      return candidate;
+      return { port: candidate, fellBackFrom: oldPort };
     }
   }
   throw new Error(`No available local port found near ${config.gateway.port}.`);
@@ -2007,8 +2194,8 @@ async function waitForGatewayReady(port, token, timeoutMs = 5000) {
 }
 function getDaemonStatus(config) {
   const pidPath = getPidPath();
-  const pid = readPidFromFile(pidPath);
-  if (!pid) {
+  const record = readPidRecordFromFile(pidPath);
+  if (!record) {
     return {
       running: false,
       pidFile: pidPath,
@@ -2016,12 +2203,15 @@ function getDaemonStatus(config) {
       port: config.gateway.port
     };
   }
+  const running = processExists(record.pid);
+  const port = record.port ?? config.gateway.port;
   return {
-    running: processExists(pid),
-    pid,
+    running,
+    pid: record.pid,
     pidFile: pidPath,
     logFile: getLogPath(),
-    port: config.gateway.port
+    port,
+    portMismatch: running && record.port !== null && record.port !== config.gateway.port
   };
 }
 async function startDaemon(config, cliPath, secrets) {
@@ -2037,16 +2227,38 @@ async function startDaemon(config, cliPath, secrets) {
       };
     }
     try {
-      fs4.unlinkSync(getPidPath());
+      fs5.unlinkSync(getPidPath());
     } catch {}
   }
-  const port = await resolveGatewayPort(config, secrets);
+  const { port, fellBackFrom } = await resolveGatewayPort(config, secrets);
+  if (fellBackFrom) {
+    process.stderr.write(`mcpx: port ${fellBackFrom} was unavailable; gateway started on ${port} instead. All client configs were re-synced to the new port.
+`);
+  }
   const token = ensureGatewayToken(config, secrets);
   const pidPath = getPidPath();
   const logPath = getLogPath();
   ensureParentDir(pidPath);
   ensureParentDir(logPath);
-  const logFd = fs4.openSync(logPath, "a", 384);
+  let logFd = fs5.openSync(logPath, "a", 384);
+  const logStat = fs5.fstatSync(logFd);
+  if (logStat.size > 10 * 1024 * 1024) {
+    fs5.closeSync(logFd);
+    const log1 = `${logPath}.1`;
+    const log2 = `${logPath}.2`;
+    try {
+      if (fs5.existsSync(log2))
+        fs5.unlinkSync(log2);
+    } catch {}
+    try {
+      if (fs5.existsSync(log1))
+        fs5.renameSync(log1, log2);
+    } catch {}
+    try {
+      fs5.renameSync(logPath, log1);
+    } catch {}
+    logFd = fs5.openSync(logPath, "a", 384);
+  }
   const child = spawn2(process.execPath, [cliPath, "daemon", "run", "--port", String(port)], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -2056,7 +2268,7 @@ async function startDaemon(config, cliPath, secrets) {
     }
   });
   child.unref();
-  fs4.writeFileSync(pidPath, `${child.pid}
+  fs5.writeFileSync(pidPath, `${child.pid}:${port}
 `, { mode: 384 });
   startBackgroundUpdateCheck();
   await waitForGatewayReady(port, token);
@@ -2078,8 +2290,9 @@ function stopDaemon() {
   }
   try {
     const cmd = execFileSync2("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8", timeout: 2000 }).trim();
-    if (!cmd.includes("mcpx") && !cmd.includes("daemon") && !cmd.includes("cli.js")) {
-      fs4.unlinkSync(pidPath);
+    const looksLikeMcpxDaemon = cmd.includes("daemon run") && (cmd.includes("mcpx") || cmd.includes("cli.js"));
+    if (!looksLikeMcpxDaemon) {
+      fs5.unlinkSync(pidPath);
       return {
         stopped: false,
         message: `PID ${pid} is not a mcpx daemon (command: ${cmd.slice(0, 80)}). Pidfile cleaned up.`
@@ -2087,7 +2300,7 @@ function stopDaemon() {
     }
   } catch {
     try {
-      fs4.unlinkSync(pidPath);
+      fs5.unlinkSync(pidPath);
     } catch {}
     return {
       stopped: false,
@@ -2098,7 +2311,7 @@ function stopDaemon() {
     process.kill(pid, "SIGTERM");
   } catch {}
   try {
-    fs4.unlinkSync(pidPath);
+    fs5.unlinkSync(pidPath);
   } catch {}
   return {
     stopped: true,
@@ -2111,10 +2324,10 @@ async function restartDaemon(config, cliPath, secrets) {
 }
 function readDaemonLogs(maxLines = 200) {
   const logPath = getLogPath();
-  if (!fs4.existsSync(logPath)) {
+  if (!fs5.existsSync(logPath)) {
     return "";
   }
-  const lines = fs4.readFileSync(logPath, "utf8").split(`
+  const lines = fs5.readFileSync(logPath, "utf8").split(`
 `);
   return lines.slice(Math.max(lines.length - maxLines, 0)).join(`
 `);
@@ -2139,7 +2352,7 @@ function runDaemonForeground(config, port, secrets) {
 }
 
 // src/core/status.ts
-var STATUS_CLIENTS = ["claude", "claude-desktop", "codex", "cursor", "cline", "opencode", "kiro", "vscode", "qwen"];
+var STATUS_CLIENTS = ["claude", "claude-desktop", "codex", "cursor", "cline", "opencode", "kiro", "vscode", "qwen", "openclaw", "hermes"];
 function describeServerTarget(spec) {
   if (spec.transport === "http") {
     return spec.url;
@@ -2192,15 +2405,15 @@ async function fetchTokenCounts(gatewayUrl, token) {
         method: "custom/tokenCounts",
         params: {}
       }),
-      signal: AbortSignal.timeout(4000)
+      signal: AbortSignal.timeout(65000)
     });
     if (!res.ok) {
-      return {};
+      return { counts: {}, fetchError: `HTTP ${res.status}` };
     }
     const data = await res.json();
-    return data?.result ?? {};
+    return { counts: data?.result ?? {} };
   } catch (error) {
-    return {};
+    return { counts: {}, fetchError: error instanceof Error ? error.message : String(error) };
   }
 }
 async function buildStatusReport(config, managedIndex, daemon = getDaemonStatus(config)) {
@@ -2208,8 +2421,11 @@ async function buildStatusReport(config, managedIndex, daemon = getDaemonStatus(
   const token = ensureGatewayToken(config, secrets);
   const gatewayUrl = getGatewayUrl(config);
   let tokenCounts = {};
+  let tokenCountFetchError;
   if (daemon.running) {
-    tokenCounts = await fetchTokenCounts(gatewayUrl, token);
+    const result = await fetchTokenCounts(gatewayUrl, token);
+    tokenCounts = result.counts;
+    tokenCountFetchError = result.fetchError;
   }
   const projectEntries = Object.values(config.projects ?? {});
   let totalGlobalTokens = 0;
@@ -2254,4 +2470,4 @@ async function buildStatusReport(config, managedIndex, daemon = getDaemonStatus(
   };
 }
 
-export { probeHttpAuthRequirement, fetchRegistryServerDetail, selectBestPackage, extractRequiredInputs, mapRegistryToSpec, toSecretRef, secretRefName, defaultAuthSecretName, resolveAuthTarget, applyAuthReference, removeAuthReference, listAuthBindings, maybePrefixBearer, buildEnrichedPath, isOAuthReference, oauthReferenceServerName, runOAuthLogin, getOAuthAccessToken, APP_VERSION, compareVersions, checkForUpdates, getStagedUpdate, shouldUseStagedCli, clearStagedUpdate, getStagedCliPath, startBackgroundUpdateCheck, runBackgroundUpdate, performUpdate, performRollback, getDaemonStatus, startDaemon, stopDaemon, restartDaemon, readDaemonLogs, runDaemonForeground, STATUS_CLIENTS, buildStatusReport };
+export { mutateConfig, mutateProjectConfig, mutateActiveConfig, probeHttpAuthRequirement, fetchRegistryServerDetail, selectBestPackage, extractRequiredInputs, mapRegistryToSpec, toSecretRef, secretRefName, defaultAuthSecretName, resolveAuthTarget, applyAuthReference, removeAuthReference, listAuthBindings, maybePrefixBearer, buildEnrichedPath, isOAuthReference, oauthReferenceServerName, runOAuthLogin, getOAuthAccessToken, compareVersions, checkForUpdates, getStagedUpdate, shouldUseStagedCli, clearStagedUpdate, getStagedCliPath, startBackgroundUpdateCheck, runBackgroundUpdate, performUpdate, performRollback, getDaemonStatus, startDaemon, stopDaemon, restartDaemon, readDaemonLogs, runDaemonForeground, STATUS_CLIENTS, buildStatusReport };