@wrongstack/mcp 0.295.0 → 0.296.2

package/dist/index.js

@@ -47,7 +47,7 @@ function parseMcpBearerChallenge(header, resource) {
   if (!header) return challenge;
   const bearer = /(?:^|,)\s*Bearer(?:\s+|$)/i.exec(header);
   if (!bearer) return challenge;
-  const parameters = header.slice((bearer.index ?? 0) + bearer[0].length);
+  const parameters = header.slice(bearer.index + bearer[0].length);
   const resourceMetadata = challengeParameter(parameters, "resource_metadata");
   if (resourceMetadata) {
     const metadataUrl = validateMetadataUrl(resourceMetadata);
@@ -395,7 +395,7 @@ async function requestPinnedJson(rawUrl, options) {
     };
     const requestFn = url.protocol === "https:" ? https.request : http.request;
     const request3 = requestFn(requestOptions, (response) => {
-      const status = response.statusCode ?? 0;
+      const status = response.statusCode;
       if (status === 404 || status === 410) {
         response.resume();
         finish(void 0, void 0);
@@ -738,9 +738,8 @@ function boundedServerName(value) {
 }
 
 // src/client.ts
-import { spawn } from "node:child_process";
-import { buildChildEnv } from "@wrongstack/core/utils";
-import { toErrorMessage } from "@wrongstack/core/utils";
+import { spawn as spawn2 } from "node:child_process";
+import { buildChildEnv, toErrorMessage } from "@wrongstack/core/utils";
 
 // src/constants.ts
 var MCP_CONSTANTS = Object.freeze({
@@ -997,13 +996,15 @@ function normalizeMCPTools(value) {
     if (typeof t.name !== "string" || t.name.trim().length === 0) continue;
     const inputSchema = t.inputSchema && typeof t.inputSchema === "object" && !Array.isArray(t.inputSchema) ? t.inputSchema : { type: "object", properties: {} };
     if (!t.inputSchema || typeof t.inputSchema !== "object" || Array.isArray(t.inputSchema)) {
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "mcp.tool_schema_invalid",
-        tool: t.name,
-        message: "no/invalid inputSchema \u2014 defaulting to empty object",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "mcp.tool_schema_invalid",
+          tool: t.name,
+          message: "no/invalid inputSchema \u2014 defaulting to empty object",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
     }
     tools.push({
       name: t.name,
@@ -1014,96 +1015,8 @@ function normalizeMCPTools(value) {
   return tools;
 }
 
-// src/transport-jsonrpc.ts
-import { ToolError } from "@wrongstack/core/types";
-function isJsonRpcResult(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const r = v;
-  if (r["jsonrpc"] !== "2.0" || typeof r["id"] !== "number") return false;
-  if (Object.hasOwn(r, "method")) return false;
-  const hasResult = Object.hasOwn(r, "result");
-  const hasError = Object.hasOwn(r, "error");
-  if (hasResult === hasError) return false;
-  if (hasError) {
-    const error = r["error"];
-    return typeof error === "object" && error !== null && typeof error["code"] === "number" && typeof error["message"] === "string";
-  }
-  return true;
-}
-function isJsonRpcMethodEnvelope(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const envelope = v;
-  if (envelope["jsonrpc"] !== "2.0" || typeof envelope["method"] !== "string") return false;
-  const id = envelope["id"];
-  return id === void 0 || typeof id === "number" || typeof id === "string";
-}
-function extractJsonRpcEnvelopes(text) {
-  const out = [];
-  let dataBuf = [];
-  const flush = () => {
-    if (dataBuf.length === 0) return;
-    const joined = dataBuf.join("\n").trim();
-    dataBuf = [];
-    if (!joined) return;
-    try {
-      const parsed = JSON.parse(joined);
-      if (isJsonRpcResult(parsed) || isJsonRpcMethodEnvelope(parsed)) out.push(parsed);
-    } catch {
-    }
-  };
-  for (const raw of text.split("\n")) {
-    const line = raw.replace(/\r$/, "");
-    if (line === "") {
-      flush();
-      continue;
-    }
-    if (line.startsWith(":")) continue;
-    if (line.startsWith("data:")) {
-      let v = line.slice(5);
-      if (v.startsWith(" ")) v = v.slice(1);
-      dataBuf.push(v);
-      continue;
-    }
-    if (line.startsWith("event:") || line.startsWith("id:") || line.startsWith("retry:")) {
-      continue;
-    }
-    const trimmed = line.trim();
-    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-      try {
-        const parsed = JSON.parse(trimmed);
-        if (isJsonRpcResult(parsed) || isJsonRpcMethodEnvelope(parsed)) out.push(parsed);
-      } catch {
-      }
-    }
-  }
-  flush();
-  return out;
-}
-function extractJsonRpcResults(text) {
-  return extractJsonRpcEnvelopes(text).filter(isJsonRpcResult);
-}
-function assertMatchingJsonRpcResult(data, expectedId, method) {
-  if (!isJsonRpcResult(data)) {
-    throw new ToolError({
-      message: "Invalid JSON-RPC response: not a JSON-RPC 2.0 envelope",
-      code: "TOOL_EXECUTION_FAILED",
-      toolName: "mcp_transport_jsonrpc",
-      context: { method, expectedId, reason: "not-jsonrpc-envelope" }
-    });
-  }
-  if (data.id !== expectedId) {
-    throw new ToolError({
-      message: `Invalid JSON-RPC response: id mismatch for ${method} (expected ${expectedId}, got ${data.id})`,
-      code: "TOOL_EXECUTION_FAILED",
-      toolName: "mcp_transport_jsonrpc",
-      context: { method, expectedId, actualId: data.id, reason: "id-mismatch" }
-    });
-  }
-  return data;
-}
-
 // src/sse-reader.ts
-import { ToolError as ToolError2 } from "@wrongstack/core/types";
+import { ToolError } from "@wrongstack/core/types";
 var SSE_READER_MAX_BUFFER = 256 * 1024;
 var SSE_READER_MAX_DATA_LINES = 1024;
 var SSEReader = class {
@@ -1119,7 +1032,7 @@ var SSEReader = class {
   }
   feed(chunk) {
     if (chunk.length > SSE_READER_MAX_BUFFER) {
-      throw new ToolError2({
+      throw new ToolError({
         message: `SSE: chunk size ${chunk.length} exceeds max buffer ${SSE_READER_MAX_BUFFER} \u2014 refusing to accumulate`,
         code: "TOOL_EXECUTION_FAILED",
         toolName: "mcp_transport_sse_reader",
@@ -1128,7 +1041,7 @@ var SSEReader = class {
     }
     this.buffer += chunk;
     if (this.buffer.length > SSE_READER_MAX_BUFFER) {
-      throw new ToolError2({
+      throw new ToolError({
         message: `SSE: pending line exceeds ${SSE_READER_MAX_BUFFER} bytes \u2014 upstream is not framing events`,
         code: "TOOL_EXECUTION_FAILED",
         toolName: "mcp_transport_sse_reader",
@@ -1163,7 +1076,7 @@ var SSEReader = class {
     if (field === "event") {
     } else if (field === "data") {
       if (this.dataLines.length >= SSE_READER_MAX_DATA_LINES) {
-        throw new ToolError2({
+        throw new ToolError({
           message: `SSE: exceeded ${SSE_READER_MAX_DATA_LINES} data lines per event \u2014 upstream is not sending blank-line delimiters`,
           code: "TOOL_EXECUTION_FAILED",
           toolName: "mcp_transport_sse_reader",
@@ -1453,9 +1366,133 @@ var BaseHTTPTransport = class {
   }
 };
 
+// src/transport-jsonrpc.ts
+import { ToolError as ToolError2 } from "@wrongstack/core/types";
+function isJsonRpcResult(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const r = v;
+  if (r["jsonrpc"] !== "2.0" || typeof r["id"] !== "number") return false;
+  if (Object.hasOwn(r, "method")) return false;
+  const hasResult = Object.hasOwn(r, "result");
+  const hasError = Object.hasOwn(r, "error");
+  if (hasResult === hasError) return false;
+  if (hasError) {
+    const error = r["error"];
+    return typeof error === "object" && error !== null && typeof error["code"] === "number" && typeof error["message"] === "string";
+  }
+  return true;
+}
+function isJsonRpcMethodEnvelope(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const envelope = v;
+  if (envelope["jsonrpc"] !== "2.0" || typeof envelope["method"] !== "string") return false;
+  const id = envelope["id"];
+  return id === void 0 || typeof id === "number" || typeof id === "string";
+}
+function extractJsonRpcEnvelopes(text) {
+  const out = [];
+  let dataBuf = [];
+  const flush = () => {
+    if (dataBuf.length === 0) return;
+    const joined = dataBuf.join("\n").trim();
+    dataBuf = [];
+    if (!joined) return;
+    try {
+      const parsed = JSON.parse(joined);
+      if (isJsonRpcResult(parsed) || isJsonRpcMethodEnvelope(parsed)) out.push(parsed);
+    } catch {
+    }
+  };
+  for (const raw of text.split("\n")) {
+    const line = raw.replace(/\r$/, "");
+    if (line === "") {
+      flush();
+      continue;
+    }
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("data:")) {
+      let v = line.slice(5);
+      if (v.startsWith(" ")) v = v.slice(1);
+      dataBuf.push(v);
+      continue;
+    }
+    if (line.startsWith("event:") || line.startsWith("id:") || line.startsWith("retry:")) {
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (isJsonRpcResult(parsed) || isJsonRpcMethodEnvelope(parsed)) out.push(parsed);
+      } catch {
+      }
+    }
+  }
+  flush();
+  return out;
+}
+function extractJsonRpcResults(text) {
+  return extractJsonRpcEnvelopes(text).filter(isJsonRpcResult);
+}
+function assertMatchingJsonRpcResult(data, expectedId, method) {
+  if (!isJsonRpcResult(data)) {
+    throw new ToolError2({
+      message: "Invalid JSON-RPC response: not a JSON-RPC 2.0 envelope",
+      code: "TOOL_EXECUTION_FAILED",
+      toolName: "mcp_transport_jsonrpc",
+      context: { method, expectedId, reason: "not-jsonrpc-envelope" }
+    });
+  }
+  if (data.id !== expectedId) {
+    throw new ToolError2({
+      message: `Invalid JSON-RPC response: id mismatch for ${method} (expected ${expectedId}, got ${data.id})`,
+      code: "TOOL_EXECUTION_FAILED",
+      toolName: "mcp_transport_jsonrpc",
+      context: { method, expectedId, actualId: data.id, reason: "id-mismatch" }
+    });
+  }
+  return data;
+}
+
 // src/transport-sse.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
+import { ToolError as ToolError4 } from "@wrongstack/core/types";
+
+// src/read-body.ts
 import { ToolError as ToolError3 } from "@wrongstack/core/types";
+var MAX_MCP_HTTP_BODY_BYTES = 16 * 1024 * 1024;
+async function readBodyCapped(res, maxBytes = MAX_MCP_HTTP_BODY_BYTES) {
+  const body = res.body;
+  if (!body || typeof body.getReader !== "function") {
+    return await res.text();
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new ToolError3({
+          message: `MCP response body exceeded ${maxBytes} bytes \u2014 refusing to buffer`,
+          code: "TOOL_EXECUTION_FAILED",
+          toolName: "mcp_transport",
+          context: { maxBytes, received: total }
+        });
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock?.();
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/transport-sse.ts
 var SSETransport = class extends BaseHTTPTransport {
   _nextId = 1;
   readerDone = false;
@@ -1502,7 +1539,7 @@ var SSETransport = class extends BaseHTTPTransport {
       this.applyTlsAgent(fetchOpts);
       const response = await this.fetchWithAuthorization(sseUrl, fetchOpts, signal);
       if (!response.ok) {
-        throw new ToolError3({
+        throw new ToolError4({
           message: `SSE connect HTTP ${response.status}: ${response.statusText}`,
           code: "TOOL_EXECUTION_FAILED",
           toolName: "mcp_transport_sse_connect",
@@ -1510,7 +1547,7 @@ var SSETransport = class extends BaseHTTPTransport {
         });
       }
       if (!response.body) {
-        throw new ToolError3({
+        throw new ToolError4({
           message: "SSE response has no body",
           code: "TOOL_EXECUTION_FAILED",
           toolName: "mcp_transport_sse_connect",
@@ -1543,7 +1580,7 @@ var SSETransport = class extends BaseHTTPTransport {
         clientInfo: MCP_CONSTANTS.CLIENT_INFO
       });
       if (initRes.error) {
-        throw new ToolError3({
+        throw new ToolError4({
           message: `initialize failed: ${initRes.error.message}`,
           code: "TOOL_EXECUTION_FAILED",
           toolName: "mcp_transport_initialize",
@@ -1618,7 +1655,7 @@ var SSETransport = class extends BaseHTTPTransport {
         const body2 = await res.text();
         const cap = MCP_CONSTANTS.REQUEST_LOG_CAP;
         const snippet = body2.length > cap ? `${body2.slice(0, cap)}\u2026 [${body2.length} bytes total]` : body2;
-        throw new ToolError3({
+        throw new ToolError4({
           message: `HTTP ${res.status}: ${snippet}`,
           code: "TOOL_EXECUTION_FAILED",
           toolName: method,
@@ -1627,9 +1664,9 @@ var SSETransport = class extends BaseHTTPTransport {
       }
       let data;
       try {
-        data = await res.json();
+        data = JSON.parse(await readBodyCapped(res));
       } catch (err) {
-        throw new ToolError3({
+        throw new ToolError4({
           message: `Invalid JSON-RPC response: ${err instanceof Error ? err.message : "parse failed"}`,
           code: "TOOL_EXECUTION_FAILED",
           toolName: method,
@@ -1654,7 +1691,7 @@ var SSETransport = class extends BaseHTTPTransport {
   }
   async callTool(name, input, opts) {
     if (this.state !== "connected") {
-      throw new ToolError3({
+      throw new ToolError4({
         message: `SSE transport not connected (state=${this.state})`,
         code: "TOOL_EXECUTION_FAILED",
         toolName: name,
@@ -1691,7 +1728,7 @@ var SSETransport = class extends BaseHTTPTransport {
     try {
       const res = await this.fetchWithAuthorization(this.url, fetchOpts, timeoutSignal.signal);
       if (!res.ok) {
-        throw new ToolError3({
+        throw new ToolError4({
           message: `HTTP ${res.status}: ${res.statusText}`,
           code: "TOOL_EXECUTION_FAILED",
           toolName: method,
@@ -1705,9 +1742,9 @@ var SSETransport = class extends BaseHTTPTransport {
       }
       let data;
       try {
-        data = await res.json();
+        data = JSON.parse(await readBodyCapped(res));
       } catch (err) {
-        throw new ToolError3({
+        throw new ToolError4({
           message: `Invalid JSON-RPC response: ${err instanceof Error ? err.message : "parse failed"}`,
           code: "TOOL_EXECUTION_FAILED",
           toolName: method,
@@ -1767,7 +1804,7 @@ var StreamableHTTPTransport = class extends BaseHTTPTransport {
       }
     }
     const responses = envelopes.filter(isJsonRpcResult);
-    return responses.find((envelope) => envelope.id === requestId) ?? responses.find((envelope) => envelope.id !== void 0) ?? responses[0];
+    return responses.find((envelope) => envelope.id === requestId) ?? responses[0];
   }
   handleNotification(method) {
     if (method === "notifications/resources/list_changed") {
@@ -1886,9 +1923,9 @@ var StreamableHTTPTransport = class extends BaseHTTPTransport {
       }
       if (method.startsWith("notifications/")) {
         await res.text().catch(() => void 0);
-        return { jsonrpc: "2.0" };
+        return { jsonrpc: "2.0", id };
       }
-      const match = this.consumeResponseText(await res.text(), id);
+      const match = this.consumeResponseText(await readBodyCapped(res), id);
       if (match) {
         return assertMatchingJsonRpcResult(match, id, method);
       }
@@ -1935,7 +1972,7 @@ var StreamableHTTPTransport = class extends BaseHTTPTransport {
         await res.text().catch(() => void 0);
         return { jsonrpc: "2.0", id };
       }
-      const parsed = this.consumeResponseText(await res.text(), id);
+      const parsed = this.consumeResponseText(await readBodyCapped(res), id);
       if (parsed) {
         return {
           jsonrpc: "2.0",
@@ -1981,19 +2018,62 @@ var StreamableHTTPTransport = class extends BaseHTTPTransport {
   }
 };
 
-// src/client.ts
-function isJsonRpcResponse(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const response = value;
-  if (response["jsonrpc"] !== "2.0" || typeof response["id"] !== "number") return false;
-  if (Object.hasOwn(response, "method")) return false;
-  const hasResult = Object.hasOwn(response, "result");
-  const hasError = Object.hasOwn(response, "error");
-  if (hasResult === hasError) return false;
-  if (!hasError) return true;
-  const error = response["error"];
-  return typeof error === "object" && error !== null && typeof error["code"] === "number" && typeof error["message"] === "string";
+// 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 {
+      child.kill("SIGKILL");
+    } catch {
+    }
+    return;
+  }
+  if (process.platform === "win32") {
+    const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    killer.once("error", () => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    });
+    killer.unref();
+    return;
+  }
+  try {
+    child.kill("SIGKILL");
+  } catch {
+  }
+}
+
+// src/client.ts
 var MCPClient = class _MCPClient {
   constructor(opts) {
     this.opts = opts;
@@ -2108,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", () => {
@@ -2386,10 +2466,7 @@ var MCPClient = class _MCPClient {
         new Promise((resolve) => setTimeout(() => resolve("timeout"), GRACEFUL_MS))
       ]);
       if (gracefulRace === "timeout") {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
+        forceKillTree(child);
         await Promise.race([
           exitPromise,
           new Promise((resolve) => setTimeout(resolve, FORCE_TIMEOUT_MS))
@@ -2618,11 +2695,12 @@ var MCPClient = class _MCPClient {
       }
       return;
     }
-    if (!isJsonRpcResponse(msg)) return;
-    if (this.pending.has(msg.id)) {
-      const entry = this.pending.get(msg.id);
-      this.pending.delete(msg.id);
-      entry?.resolve(msg);
+    if (!isJsonRpcResult(msg)) return;
+    const response = msg;
+    if (this.pending.has(response.id)) {
+      const entry = this.pending.get(response.id);
+      this.pending.delete(response.id);
+      entry?.resolve(response);
     }
   }
   handleServerRequest(request3) {
@@ -2689,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;
@@ -2856,7 +2911,7 @@ async function writeConfig(path2, cfg) {
   try {
     await fs.rename(tmp, path2);
   } catch (err) {
-    await fs.rm(tmp, { force: true }).catch(() => void 0);
+    await fs.rm(tmp, { force: true });
     throw err;
   }
 }
@@ -3096,7 +3151,7 @@ function forgetRegistryState(registry, name) {
 }
 
 // src/manifest-cache.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash2, randomBytes as randomBytes4 } from "node:crypto";
 import * as fs2 from "node:fs/promises";
 import * as path from "node:path";
 function manifestConfigHash(cfg) {
@@ -3144,9 +3199,14 @@ async function writeCapabilityManifest(cacheDir, name, configHash, manifest) {
     const file = manifestFile(cacheDir, name);
     await fs2.mkdir(path.dirname(file), { recursive: true });
     const body = { version: 2, configHash, ...manifest };
-    const tmp = `${file}.tmp`;
-    await fs2.writeFile(tmp, JSON.stringify(body, null, 2), "utf8");
-    await fs2.rename(tmp, file);
+    const tmp = `${file}.${process.pid}.${randomBytes4(6).toString("hex")}.tmp`;
+    try {
+      await fs2.writeFile(tmp, JSON.stringify(body, null, 2), "utf8");
+      await fs2.rename(tmp, file);
+    } catch (err) {
+      await fs2.rm(tmp, { force: true });
+      throw err;
+    }
   } catch {
   }
 }
@@ -3207,7 +3267,10 @@ function evaluateHealthThresholds(operations, thresholds) {
   if (!thresholds) return [];
   const checks = [];
   if (thresholds.connectionLatencyP95Ms !== void 0 && operations.connectionSamples.length > 0) {
-    const value = percentile([...operations.connectionSamples].sort((a, b) => a - b), 0.95);
+    const value = percentile(
+      [...operations.connectionSamples].sort((a, b) => a - b),
+      0.95
+    );
     checks.push({
       name: "connection-latency-p95",
       passed: value <= thresholds.connectionLatencyP95Ms,
@@ -3216,7 +3279,10 @@ function evaluateHealthThresholds(operations, thresholds) {
     });
   }
   if (thresholds.discoveryLatencyP95Ms !== void 0 && operations.discoverySamples.length > 0) {
-    const value = percentile([...operations.discoverySamples].sort((a, b) => a - b), 0.95);
+    const value = percentile(
+      [...operations.discoverySamples].sort((a, b) => a - b),
+      0.95
+    );
     checks.push({
       name: "discovery-latency-p95",
       passed: value <= thresholds.discoveryLatencyP95Ms,
@@ -3225,7 +3291,10 @@ function evaluateHealthThresholds(operations, thresholds) {
     });
   }
   if (thresholds.callLatencyP95Ms !== void 0 && operations.callSamples.length > 0) {
-    const value = percentile([...operations.callSamples].sort((a, b) => a - b), 0.95);
+    const value = percentile(
+      [...operations.callSamples].sort((a, b) => a - b),
+      0.95
+    );
     checks.push({
       name: "call-latency-p95",
       passed: value <= thresholds.callLatencyP95Ms,
@@ -3275,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;
@@ -3372,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) {
@@ -3461,11 +3743,7 @@ var MCPRegistry = class _MCPRegistry {
    * cache yet, do a one-time cold discovery connect to learn + cache the tools.
    */
   async startLazy(slot) {
-    const cacheDir = this.cacheDir;
-    if (!cacheDir) {
-      await this.attemptConnect(slot);
-      return;
-    }
+    const cacheDir = expectDefined(this.cacheDir);
     const hash = manifestConfigHash(slot.cfg);
     const cached = await readCapabilityManifest(cacheDir, slot.cfg.name, hash);
     if (cached) {
@@ -3627,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);
@@ -3720,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);
@@ -3808,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
         );
@@ -3818,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
         );
@@ -3833,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
         );
@@ -4012,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"}` });
@@ -4043,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;
@@ -4115,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;
@@ -4267,44 +4415,10 @@ 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";
-import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
-import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+import { expectDefined as expectDefined2, toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
 var PARSE_ERROR = -32700;
 var INVALID_REQUEST = -32600;
 var METHOD_NOT_FOUND = -32601;
@@ -4629,8 +4743,7 @@ function serveHttp(server, opts = {}) {
     httpServer.once("error", reject);
     httpServer.listen(port, host, () => {
       httpServer.removeListener("error", reject);
-      const addr = httpServer.address();
-      const boundPort = typeof addr === "object" && addr ? addr.port : port;
+      const boundPort = httpServer.address().port;
       const displayHost = host === "::1" ? "[::1]" : host;
       resolve({
         port: boundPort,
@@ -4662,18 +4775,14 @@ async function handleHttpRequest(server, req, res, token, log) {
     }
   }
   let body = "";
-  let tooLarge = false;
   req.on("data", (chunk) => {
-    if (tooLarge) return;
     body += chunk.toString("utf8");
     if (body.length > HTTP_BODY_CAP) {
-      tooLarge = true;
       send(413, JSON.stringify({ error: "payload too large" }));
       req.destroy();
     }
   });
   req.on("end", () => {
-    if (tooLarge) return;
     void server.handleMessage(body).then((out) => {
       if (out === null) return send(202, "");
       return send(200, out);