@wrongstack/mcp 0.295.1 → 0.296.2

package/dist/index.js

@@ -738,7 +738,7 @@ function boundedServerName(value) {
 }
 
 // src/client.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { buildChildEnv, toErrorMessage } from "@wrongstack/core/utils";
 
 // src/constants.ts
@@ -2018,7 +2018,33 @@ var StreamableHTTPTransport = class extends BaseHTTPTransport {
   }
 };
 
-// src/client.ts
+// src/client-protocol-helpers.ts
+function quoteWindowsArg(arg) {
+  if (!/[\s"]/.test(arg)) return arg;
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+var MAX_PROTOCOL_INPUT_CHARS = 8192;
+function validateProtocolString(value, label, allowEmpty = false) {
+  if (typeof value !== "string" || !allowEmpty && value.length === 0) {
+    throw new Error(`MCP ${label} must be ${allowEmpty ? "a string" : "a non-empty string"}`);
+  }
+  if (value.length > MAX_PROTOCOL_INPUT_CHARS) {
+    throw new Error(`MCP ${label} exceeds ${MAX_PROTOCOL_INPUT_CHARS} characters`);
+  }
+}
+function pageParams(cursor, label) {
+  if (cursor === void 0) return {};
+  validateProtocolString(cursor, label);
+  return { cursor };
+}
+function parseEmptyResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Malformed MCP empty result: expected object");
+  }
+}
+
+// src/client-process.ts
+import { spawn } from "node:child_process";
 function forceKillTree(child) {
   if (child.pid === void 0) {
     try {
@@ -2046,6 +2072,8 @@ function forceKillTree(child) {
   } catch {
   }
 }
+
+// src/client.ts
 var MCPClient = class _MCPClient {
   constructor(opts) {
     this.opts = opts;
@@ -2160,14 +2188,14 @@ var MCPClient = class _MCPClient {
     const rawArgs = this.opts.args ?? [];
     const spawnEnv = buildChildEnv({ extra: extraEnv });
     const stdio = ["pipe", "pipe", "pipe"];
-    const child = isWin ? spawn([this.opts.command, ...rawArgs].map(quoteWindowsArg).join(" "), {
+    const child = isWin ? spawn2([this.opts.command, ...rawArgs].map(quoteWindowsArg).join(" "), {
       env: spawnEnv,
       stdio,
       shell: true,
       // Without this every MCP server spawned from a console-less host
       // (WebUI server, scheduled runs) opens a visible console window.
       windowsHide: true
-    }) : spawn(this.opts.command, rawArgs, { env: spawnEnv, stdio, windowsHide: true });
+    }) : spawn2(this.opts.command, rawArgs, { env: spawnEnv, stdio, windowsHide: true });
     this.child = child;
     child.stdout?.on("data", (chunk) => this.onData(chunk.toString()));
     child.stderr?.on("data", () => {
@@ -2739,29 +2767,6 @@ var MCPClient = class _MCPClient {
     }
   }
 };
-function quoteWindowsArg(arg) {
-  if (!/[\s"]/.test(arg)) return arg;
-  return `"${arg.replace(/"/g, '""')}"`;
-}
-var MAX_PROTOCOL_INPUT_CHARS = 8192;
-function validateProtocolString(value, label, allowEmpty = false) {
-  if (typeof value !== "string" || !allowEmpty && value.length === 0) {
-    throw new Error(`MCP ${label} must be ${allowEmpty ? "a string" : "a non-empty string"}`);
-  }
-  if (value.length > MAX_PROTOCOL_INPUT_CHARS) {
-    throw new Error(`MCP ${label} exceeds ${MAX_PROTOCOL_INPUT_CHARS} characters`);
-  }
-}
-function pageParams(cursor, label) {
-  if (cursor === void 0) return {};
-  validateProtocolString(cursor, label);
-  return { cursor };
-}
-function parseEmptyResult(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Malformed MCP empty result: expected object");
-  }
-}
 
 // src/content-selection.ts
 var DEFAULT_MCP_INSERTION_MAX_BYTES = 256 * 1024;
@@ -3339,6 +3344,230 @@ function percentile(sorted, ratio) {
 // src/registry.ts
 import { expectDefined } from "@wrongstack/core/utils";
 
+// src/registry-catalog.ts
+var MAX_CATALOG_PAGES = 100;
+var MAX_CATALOG_ITEMS = 1e4;
+async function collectCatalogPages(load, select) {
+  const items = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  for (let pageNumber = 0; pageNumber < MAX_CATALOG_PAGES; pageNumber++) {
+    const page = await load(cursor);
+    items.push(...select(page));
+    if (items.length > MAX_CATALOG_ITEMS) {
+      throw new Error(`MCP catalog exceeds ${MAX_CATALOG_ITEMS} items`);
+    }
+    const next = page.nextCursor;
+    if (!next) return items;
+    if (seenCursors.has(next)) throw new Error(`MCP catalog repeated cursor "${next}"`);
+    seenCursors.add(next);
+    cursor = next;
+  }
+  throw new Error(`MCP catalog exceeds ${MAX_CATALOG_PAGES} pages`);
+}
+function cloneCatalogRecords(records) {
+  return structuredClone(records);
+}
+function registryCatalogSnapshot(slot) {
+  return {
+    name: slot.cfg.name,
+    state: slot.state,
+    serverMetadata: slot.serverMetadata ? structuredClone(slot.serverMetadata) : void 0,
+    resources: slot.resources ? cloneCatalogRecords(slot.resources) : void 0,
+    resourceTemplates: slot.resourceTemplates ? cloneCatalogRecords(slot.resourceTemplates) : void 0,
+    prompts: slot.prompts ? cloneCatalogRecords(slot.prompts) : void 0
+  };
+}
+
+// src/registry-health.ts
+function buildRegistryOperationalHealth(servers, disabledServers) {
+  const active = Array.from(servers).map((slot) => {
+    const op = slot.operations;
+    const baseHealth = healthStateFor(slot.state, op, slot.cfg.enabled !== false);
+    const checks = evaluateHealthThresholds(op, slot.cfg.health?.thresholds);
+    return {
+      name: slot.cfg.name,
+      connectionState: slot.state,
+      healthState: applyHealthThresholds(baseHealth, checks),
+      lastSuccessAt: op.lastSuccessAt,
+      lastFailureAt: op.lastFailureAt,
+      lastFailureKind: op.lastFailureKind,
+      lastReason: op.lastReason,
+      consecutiveFailures: op.consecutiveFailures,
+      failures: { ...op.failures },
+      reconnectCount: op.reconnectCount,
+      wakeCount: op.wakeCount,
+      sleepCount: op.sleepCount,
+      restartCount: op.restartCount,
+      connectionLatency: summarizeLatency(op.connectionSamples),
+      discoveryLatency: summarizeLatency(op.discoverySamples),
+      callLatency: summarizeLatency(op.callSamples),
+      inFlightCalls: op.inFlightCalls,
+      peakInFlightCalls: op.peakInFlightCalls,
+      recentEvents: op.recentEvents.map((event) => ({ ...event })),
+      healthChecks: checks
+    };
+  });
+  const disabled = Array.from(disabledServers).map((cfg) => {
+    const operations = createMCPServerOperationState();
+    return {
+      name: cfg.name,
+      connectionState: "idle",
+      healthState: "disabled",
+      consecutiveFailures: 0,
+      failures: { ...operations.failures },
+      reconnectCount: 0,
+      wakeCount: 0,
+      sleepCount: 0,
+      restartCount: 0,
+      connectionLatency: summarizeLatency([]),
+      discoveryLatency: summarizeLatency([]),
+      callLatency: summarizeLatency([]),
+      inFlightCalls: 0,
+      peakInFlightCalls: 0,
+      recentEvents: [],
+      healthChecks: []
+    };
+  });
+  return [...active, ...disabled];
+}
+
+// src/registry-authorization.ts
+function requireAuthorizationManager(manager) {
+  if (!manager) {
+    throw new Error("MCP authorization management is not configured for this host");
+  }
+  return manager;
+}
+function requireHttpServerConfig(servers, disabledServers, name) {
+  const cfg = servers.get(name)?.cfg ?? disabledServers.get(name);
+  if (!cfg) throw new Error(`MCP server "${name}" not registered`);
+  if (cfg.transport === "stdio" || !cfg.url) {
+    throw new Error(`MCP server "${name}" does not use an HTTP transport`);
+  }
+  return cfg;
+}
+async function beginRegistryAuthorization(manager, cfg, name, input) {
+  return requireAuthorizationManager(manager).begin({
+    serverName: name,
+    resource: cfg.url,
+    ...input
+  });
+}
+async function completeRegistryAuthorization(manager, cfg, name, callbackUrl, signal) {
+  return requireAuthorizationManager(manager).complete({
+    serverName: name,
+    resource: cfg.url,
+    callbackUrl,
+    signal
+  });
+}
+
+// src/registry-operations.ts
+function operationsForSlot(slot) {
+  if (!slot.operations) slot.operations = createMCPServerOperationState();
+  return slot.operations;
+}
+function recordRegistrySuccess(slot, resetFailures = true) {
+  const operations = operationsForSlot(slot);
+  operations.lastSuccessAt = Date.now();
+  if (resetFailures) operations.consecutiveFailures = 0;
+}
+function recordRegistryFailure(slot, listeners, failureKind, reason, durationMs) {
+  const operations = operationsForSlot(slot);
+  const safeReason = safeOperationReason(reason);
+  operations.lastFailureAt = Date.now();
+  operations.lastFailureKind = failureKind;
+  operations.lastReason = safeReason;
+  operations.consecutiveFailures++;
+  operations.failures[failureKind]++;
+  recordRegistryOperation(slot, listeners, "failure", safeReason, failureKind, durationMs);
+}
+function recordRegistryOperation(slot, listeners, kind, reason, failureKind, durationMs, retain = true) {
+  const operations = operationsForSlot(slot);
+  const baseHealth = healthStateFor(slot.state, operations, slot.cfg.enabled !== false);
+  const checks = evaluateHealthThresholds(operations, slot.cfg.health?.thresholds);
+  const event = {
+    serverName: slot.cfg.name,
+    kind,
+    at: Date.now(),
+    connectionState: slot.state,
+    healthState: applyHealthThresholds(baseHealth, checks)
+  };
+  if (reason !== void 0) event.reason = safeOperationReason(reason);
+  if (failureKind !== void 0) event.failureKind = failureKind;
+  if (durationMs !== void 0) event.durationMs = Math.max(0, Math.round(durationMs));
+  if (retain) pushBounded(operations.recentEvents, event, MCP_OPERATION_LIMITS.RECENT_EVENTS);
+  for (const listener of listeners) {
+    try {
+      listener({ ...event });
+    } catch {
+    }
+  }
+}
+
+// src/registry-disconnect.ts
+function resetDisconnectedSlotTools(slot, toolRegistry) {
+  for (const t of slot.toolNames) {
+    try {
+      toolRegistry.unregister(t);
+    } catch {
+    }
+  }
+  slot.toolNames = [];
+  slot.lazyTools = [];
+  slot.serverMetadata = void 0;
+  slot.resources = void 0;
+  slot.resourceTemplates = void 0;
+  slot.prompts = void 0;
+}
+function markLazySlotDormant(slot, events, reason) {
+  slot.client = void 0;
+  slot.state = "dormant";
+  events.emit("mcp.server.disconnected", {
+    name: slot.cfg.name,
+    reason: `${reason} (dormant)`
+  });
+}
+
+// src/registry-reconnect.ts
+function scheduleRegistryReconnect({
+  slot,
+  events,
+  log,
+  maxReconnectCycles,
+  baseReconnectDelayMs,
+  maxReconnectDelayMs,
+  recordReconnectExhausted,
+  attemptReconnect
+}) {
+  if (slot.reconnectPending) return;
+  if (slot.reconnectCycles >= maxReconnectCycles) {
+    slot.state = "failed";
+    recordReconnectExhausted(slot);
+    log.error(
+      `MCP server "${slot.cfg.name}" giving up after ${slot.reconnectCycles} reconnect cycles. Use \`/mcp restart ${slot.cfg.name}\` to retry.`
+    );
+    events.emit("mcp.server.disconnected", {
+      name: slot.cfg.name,
+      reason: `reconnect-exhausted:${slot.reconnectCycles}`
+    });
+    return;
+  }
+  slot.reconnectPending = true;
+  if (slot.reconnectTimer) {
+    clearTimeout(slot.reconnectTimer);
+    slot.reconnectTimer = void 0;
+  }
+  const base = Math.min(baseReconnectDelayMs * 2 ** slot.reconnectCycles, maxReconnectDelayMs);
+  const jitter = base * MCP_CONSTANTS.RECONNECT.JITTER_FACTOR * (Math.random() * 2 - 1);
+  const delay = Math.max(100, Math.round(base + jitter));
+  slot.reconnectTimer = setTimeout(() => {
+    slot.reconnectTimer = void 0;
+    void attemptReconnect(slot);
+  }, delay);
+}
+
 // src/wrap-tool.ts
 import { ToolCapabilities } from "@wrongstack/core/security";
 var MUTATING_RE = /create|update|delete|write|send|set|put|post|patch|remove|rename|move/i;
@@ -3436,42 +3665,31 @@ var MCPRegistry = class _MCPRegistry {
     return slot;
   }
   async beginAuthorization(name, input) {
-    const manager = this.requireAuthorizationManager();
     const cfg = this.requireHttpServerConfig(name);
-    return manager.begin({
-      serverName: name,
-      resource: cfg.url,
-      ...input
-    });
+    return beginRegistryAuthorization(this.authorizationManager, cfg, name, input);
   }
   async completeAuthorization(name, callbackUrl, signal) {
-    const manager = this.requireAuthorizationManager();
     const cfg = this.requireHttpServerConfig(name);
-    return manager.complete({ serverName: name, resource: cfg.url, callbackUrl, signal });
+    return completeRegistryAuthorization(
+      this.authorizationManager,
+      cfg,
+      name,
+      callbackUrl,
+      signal
+    );
   }
   async authorizationStatus(name) {
-    const manager = this.requireAuthorizationManager();
+    const manager = requireAuthorizationManager(this.authorizationManager);
     const cfg = this.requireHttpServerConfig(name);
     return manager.status(name, cfg.url);
   }
   async disconnectAuthorization(name) {
-    const manager = this.requireAuthorizationManager();
+    const manager = requireAuthorizationManager(this.authorizationManager);
     const cfg = this.requireHttpServerConfig(name);
     return manager.disconnect(name, cfg.url);
   }
-  requireAuthorizationManager() {
-    if (!this.authorizationManager) {
-      throw new Error("MCP authorization management is not configured for this host");
-    }
-    return this.authorizationManager;
-  }
   requireHttpServerConfig(name) {
-    const cfg = this.servers.get(name)?.cfg ?? this.disabledServers.get(name);
-    if (!cfg) throw new Error(`MCP server "${name}" not registered`);
-    if (cfg.transport === "stdio" || !cfg.url) {
-      throw new Error(`MCP server "${name}" does not use an HTTP transport`);
-    }
-    return cfg;
+    return requireHttpServerConfig(this.servers, this.disabledServers, name);
   }
   async start(cfg) {
     if (cfg.enabled === false) {
@@ -3687,84 +3905,36 @@ var MCPRegistry = class _MCPRegistry {
   }
   /** Detailed, defensively-copied operational snapshots for CLI/WebUI/HQ. */
   operationalHealth() {
-    const active = Array.from(this.servers.values()).map((slot) => {
-      const op = slot.operations;
-      const baseHealth = healthStateFor(slot.state, op, slot.cfg.enabled !== false);
-      const checks = evaluateHealthThresholds(op, slot.cfg.health?.thresholds);
-      return {
-        name: slot.cfg.name,
-        connectionState: slot.state,
-        healthState: applyHealthThresholds(baseHealth, checks),
-        lastSuccessAt: op.lastSuccessAt,
-        lastFailureAt: op.lastFailureAt,
-        lastFailureKind: op.lastFailureKind,
-        lastReason: op.lastReason,
-        consecutiveFailures: op.consecutiveFailures,
-        failures: { ...op.failures },
-        reconnectCount: op.reconnectCount,
-        wakeCount: op.wakeCount,
-        sleepCount: op.sleepCount,
-        restartCount: op.restartCount,
-        connectionLatency: summarizeLatency(op.connectionSamples),
-        discoveryLatency: summarizeLatency(op.discoverySamples),
-        callLatency: summarizeLatency(op.callSamples),
-        inFlightCalls: op.inFlightCalls,
-        peakInFlightCalls: op.peakInFlightCalls,
-        recentEvents: op.recentEvents.map((event) => ({ ...event })),
-        healthChecks: checks
-      };
-    });
-    const disabled = Array.from(this.disabledServers.values()).map((cfg) => {
-      const operations = createMCPServerOperationState();
-      return {
-        name: cfg.name,
-        connectionState: "idle",
-        healthState: "disabled",
-        consecutiveFailures: 0,
-        failures: { ...operations.failures },
-        reconnectCount: 0,
-        wakeCount: 0,
-        sleepCount: 0,
-        restartCount: 0,
-        connectionLatency: summarizeLatency([]),
-        discoveryLatency: summarizeLatency([]),
-        callLatency: summarizeLatency([]),
-        inFlightCalls: 0,
-        peakInFlightCalls: 0,
-        recentEvents: [],
-        healthChecks: []
-      };
-    });
-    return [...active, ...disabled];
+    return buildRegistryOperationalHealth(this.servers.values(), this.disabledServers.values());
   }
   getCatalog(name) {
     const slot = this.servers.get(name);
     if (!slot) return void 0;
-    return catalogSnapshot(slot);
+    return registryCatalogSnapshot(slot);
   }
   async listResources(name, opts = {}) {
     const slot = this.requireSlot(name);
-    if (!opts.refresh && slot.resources) return cloneRecords(slot.resources);
+    if (!opts.refresh && slot.resources) return cloneCatalogRecords(slot.resources);
     const client = await this.ensureConnected(name);
     if (!client.getServerMetadata()?.capabilities.resources) return [];
-    slot.resources = await collectPages(
+    slot.resources = await collectCatalogPages(
       (cursor) => client.listResources(cursor ? { cursor } : {}),
       (page) => page.resources
     );
     await this.persistCapabilityManifest(slot);
-    return cloneRecords(slot.resources);
+    return cloneCatalogRecords(slot.resources);
   }
   async listResourceTemplates(name, opts = {}) {
     const slot = this.requireSlot(name);
-    if (!opts.refresh && slot.resourceTemplates) return cloneRecords(slot.resourceTemplates);
+    if (!opts.refresh && slot.resourceTemplates) return cloneCatalogRecords(slot.resourceTemplates);
     const client = await this.ensureConnected(name);
     if (!client.getServerMetadata()?.capabilities.resources) return [];
-    slot.resourceTemplates = await collectPages(
+    slot.resourceTemplates = await collectCatalogPages(
       (cursor) => client.listResourceTemplates(cursor ? { cursor } : {}),
       (page) => page.resourceTemplates
     );
     await this.persistCapabilityManifest(slot);
-    return cloneRecords(slot.resourceTemplates);
+    return cloneCatalogRecords(slot.resourceTemplates);
   }
   async readResource(name, uri) {
     return (await this.ensureConnected(name)).readResource(uri);
@@ -3780,15 +3950,15 @@ var MCPRegistry = class _MCPRegistry {
   }
   async listPrompts(name, opts = {}) {
     const slot = this.requireSlot(name);
-    if (!opts.refresh && slot.prompts) return cloneRecords(slot.prompts);
+    if (!opts.refresh && slot.prompts) return cloneCatalogRecords(slot.prompts);
     const client = await this.ensureConnected(name);
     if (!client.getServerMetadata()?.capabilities.prompts) return [];
-    slot.prompts = await collectPages(
+    slot.prompts = await collectCatalogPages(
       (cursor) => client.listPrompts(cursor ? { cursor } : {}),
       (page) => page.prompts
     );
     await this.persistCapabilityManifest(slot);
-    return cloneRecords(slot.prompts);
+    return cloneCatalogRecords(slot.prompts);
   }
   async getPrompt(serverName, promptName, args) {
     return (await this.ensureConnected(serverName)).getPrompt(promptName, args);
@@ -3868,7 +4038,7 @@ var MCPRegistry = class _MCPRegistry {
     const capabilities = slot.serverMetadata?.capabilities;
     if (capabilities?.resources) {
       try {
-        slot.resources = await collectPages(
+        slot.resources = await collectCatalogPages(
           (cursor) => client.listResources(cursor ? { cursor } : {}),
           (page) => page.resources
         );
@@ -3878,7 +4048,7 @@ var MCPRegistry = class _MCPRegistry {
         this.log.warn(`MCP server "${slot.cfg.name}" resource discovery failed`, err);
       }
       try {
-        slot.resourceTemplates = await collectPages(
+        slot.resourceTemplates = await collectCatalogPages(
           (cursor) => client.listResourceTemplates(cursor ? { cursor } : {}),
           (page) => page.resourceTemplates
         );
@@ -3893,7 +4063,7 @@ var MCPRegistry = class _MCPRegistry {
     }
     if (capabilities?.prompts) {
       try {
-        slot.prompts = await collectPages(
+        slot.prompts = await collectCatalogPages(
           (cursor) => client.listPrompts(cursor ? { cursor } : {}),
           (page) => page.prompts
         );
@@ -4072,27 +4242,11 @@ var MCPRegistry = class _MCPRegistry {
     const slot = this.servers.get(name);
     if (!slot) return;
     if (slot.lazy) {
-      slot.client = void 0;
-      slot.state = "dormant";
       this.recordFailure(slot, "transport", "process-exit-lazy");
-      this.events.emit("mcp.server.disconnected", {
-        name,
-        reason: `exit:${code ?? "unknown"} (dormant)`
-      });
+      markLazySlotDormant(slot, this.events, `exit:${code ?? "unknown"}`);
       return;
     }
-    for (const t of slot.toolNames) {
-      try {
-        this.toolRegistry.unregister(t);
-      } catch {
-      }
-    }
-    slot.toolNames = [];
-    slot.lazyTools = [];
-    slot.serverMetadata = void 0;
-    slot.resources = void 0;
-    slot.resourceTemplates = void 0;
-    slot.prompts = void 0;
+    resetDisconnectedSlotTools(slot, this.toolRegistry);
     slot.state = "disconnected";
     this.recordFailure(slot, "transport", "process-exit");
     this.events.emit("mcp.server.disconnected", { name, reason: `exit:${code ?? "unknown"}` });
@@ -4103,69 +4257,30 @@ var MCPRegistry = class _MCPRegistry {
     const slot = this.servers.get(name);
     if (!slot) return;
     if (slot.lazy) {
-      slot.client = void 0;
-      slot.state = "dormant";
       this.recordFailure(slot, "transport", "http-disconnect-lazy");
-      this.events.emit("mcp.server.disconnected", { name, reason: "http-disconnect (dormant)" });
+      markLazySlotDormant(slot, this.events, "http-disconnect");
       return;
     }
-    for (const t of slot.toolNames) {
-      try {
-        this.toolRegistry.unregister(t);
-      } catch {
-      }
-    }
-    slot.toolNames = [];
-    slot.lazyTools = [];
-    slot.serverMetadata = void 0;
-    slot.resources = void 0;
-    slot.resourceTemplates = void 0;
-    slot.prompts = void 0;
+    resetDisconnectedSlotTools(slot, this.toolRegistry);
     slot.state = "disconnected";
     this.recordFailure(slot, "transport", "http-disconnect");
     this.events.emit("mcp.server.disconnected", { name, reason: "http-disconnect" });
     this.scheduleReconnect(slot);
   };
-  /**
-   * L2-B: maximum number of reconnect cycles before staying `failed`.
-   * One cycle = one full `attemptConnect` (which itself may try up to 3
-   * times). Caps total reconnect storm at ~5 cycles, then the slot
-   * needs an explicit `restart()` to re-engage.
-   */
   static MAX_RECONNECT_CYCLES = MCP_CONSTANTS.RECONNECT.MAX_CYCLES;
-  /** Base delay between cycles, in ms. Real delay adds jitter. */
   static BASE_RECONNECT_DELAY_MS = MCP_CONSTANTS.RECONNECT.BASE_DELAY_MS;
-  /** Hard ceiling on the inter-cycle delay so the user doesn't wait minutes. */
   static MAX_RECONNECT_DELAY_MS = 3e4;
   scheduleReconnect(slot) {
-    if (slot.reconnectPending) return;
-    if (slot.reconnectCycles >= _MCPRegistry.MAX_RECONNECT_CYCLES) {
-      slot.state = "failed";
-      this.recordFailure(slot, "transport", "reconnect-exhausted");
-      this.log.error(
-        `MCP server "${slot.cfg.name}" giving up after ${slot.reconnectCycles} reconnect cycles. Use \`/mcp restart ${slot.cfg.name}\` to retry.`
-      );
-      this.events.emit("mcp.server.disconnected", {
-        name: slot.cfg.name,
-        reason: `reconnect-exhausted:${slot.reconnectCycles}`
-      });
-      return;
-    }
-    slot.reconnectPending = true;
-    if (slot.reconnectTimer) {
-      clearTimeout(slot.reconnectTimer);
-      slot.reconnectTimer = void 0;
-    }
-    const base = Math.min(
-      _MCPRegistry.BASE_RECONNECT_DELAY_MS * 2 ** slot.reconnectCycles,
-      _MCPRegistry.MAX_RECONNECT_DELAY_MS
-    );
-    const jitter = base * MCP_CONSTANTS.RECONNECT.JITTER_FACTOR * (Math.random() * 2 - 1);
-    const delay = Math.max(100, Math.round(base + jitter));
-    slot.reconnectTimer = setTimeout(() => {
-      slot.reconnectTimer = void 0;
-      void this.attemptReconnect(slot);
-    }, delay);
+    scheduleRegistryReconnect({
+      slot,
+      events: this.events,
+      log: this.log,
+      maxReconnectCycles: _MCPRegistry.MAX_RECONNECT_CYCLES,
+      baseReconnectDelayMs: _MCPRegistry.BASE_RECONNECT_DELAY_MS,
+      maxReconnectDelayMs: _MCPRegistry.MAX_RECONNECT_DELAY_MS,
+      recordReconnectExhausted: (target) => this.recordFailure(target, "transport", "reconnect-exhausted"),
+      attemptReconnect: (target) => this.attemptReconnect(target)
+    });
   }
   async attemptReconnect(slot) {
     slot.reconnectPending = false;
@@ -4175,48 +4290,21 @@ var MCPRegistry = class _MCPRegistry {
     await this.attemptConnect(slot);
   }
   recordSuccess(slot, resetFailures = true) {
-    const operations = this.operationsFor(slot);
-    operations.lastSuccessAt = Date.now();
-    if (resetFailures) operations.consecutiveFailures = 0;
+    recordRegistrySuccess(slot, resetFailures);
   }
   recordFailure(slot, failureKind, reason, durationMs) {
-    const operations = this.operationsFor(slot);
-    const safeReason = safeOperationReason(reason);
-    operations.lastFailureAt = Date.now();
-    operations.lastFailureKind = failureKind;
-    operations.lastReason = safeReason;
-    operations.consecutiveFailures++;
-    operations.failures[failureKind]++;
-    this.recordOperation(slot, "failure", safeReason, failureKind, durationMs);
+    recordRegistryFailure(slot, this.operationListeners, failureKind, reason, durationMs);
   }
   recordOperation(slot, kind, reason, failureKind, durationMs, retain = true) {
-    const operations = this.operationsFor(slot);
-    const baseHealth = healthStateFor(slot.state, operations, slot.cfg.enabled !== false);
-    const checks = evaluateHealthThresholds(operations, slot.cfg.health?.thresholds);
-    const event = {
-      serverName: slot.cfg.name,
+    recordRegistryOperation(
+      slot,
+      this.operationListeners,
       kind,
-      at: Date.now(),
-      connectionState: slot.state,
-      healthState: applyHealthThresholds(baseHealth, checks)
-    };
-    if (reason !== void 0) event.reason = safeOperationReason(reason);
-    if (failureKind !== void 0) event.failureKind = failureKind;
-    if (durationMs !== void 0) event.durationMs = Math.max(0, Math.round(durationMs));
-    if (retain) {
-      pushBounded(operations.recentEvents, event, MCP_OPERATION_LIMITS.RECENT_EVENTS);
-    }
-    for (const listener of this.operationListeners) {
-      try {
-        listener({ ...event });
-      } catch {
-      }
-    }
-  }
-  /** Keeps private-method unit fixtures from needing to duplicate every slot field. */
-  operationsFor(slot) {
-    if (!slot.operations) slot.operations = createMCPServerOperationState();
-    return slot.operations;
+      reason,
+      failureKind,
+      durationMs,
+      retain
+    );
   }
   async attemptConnect(slot) {
     const MAX_ATTEMPTS = MCP_CONSTANTS.RECONNECT.MAX_ATTEMPTS;
@@ -4327,39 +4415,6 @@ var MCPRegistry = class _MCPRegistry {
     }
   }
 };
-var MAX_CATALOG_PAGES = 100;
-var MAX_CATALOG_ITEMS = 1e4;
-async function collectPages(load, select) {
-  const items = [];
-  const seenCursors = /* @__PURE__ */ new Set();
-  let cursor;
-  for (let pageNumber = 0; pageNumber < MAX_CATALOG_PAGES; pageNumber++) {
-    const page = await load(cursor);
-    items.push(...select(page));
-    if (items.length > MAX_CATALOG_ITEMS) {
-      throw new Error(`MCP catalog exceeds ${MAX_CATALOG_ITEMS} items`);
-    }
-    const next = page.nextCursor;
-    if (!next) return items;
-    if (seenCursors.has(next)) throw new Error(`MCP catalog repeated cursor "${next}"`);
-    seenCursors.add(next);
-    cursor = next;
-  }
-  throw new Error(`MCP catalog exceeds ${MAX_CATALOG_PAGES} pages`);
-}
-function cloneRecords(records) {
-  return structuredClone(records);
-}
-function catalogSnapshot(slot) {
-  return {
-    name: slot.cfg.name,
-    state: slot.state,
-    serverMetadata: slot.serverMetadata ? structuredClone(slot.serverMetadata) : void 0,
-    resources: slot.resources ? cloneRecords(slot.resources) : void 0,
-    resourceTemplates: slot.resourceTemplates ? cloneRecords(slot.resourceTemplates) : void 0,
-    prompts: slot.prompts ? cloneRecords(slot.prompts) : void 0
-  };
-}
 
 // src/server.ts
 import { createServer } from "node:http";