@wrongstack/mcp 0.275.0 → 0.276.2

package/dist/index.js

@@ -1,5 +1,5 @@
 import { spawn } from 'child_process';
-import { expectDefined, ToolCapabilities, buildChildEnv } from '@wrongstack/core';
+import { expectDefined, ToolCapabilities, buildChildEnv, ToolError, ConfigError } from '@wrongstack/core';
 import { createHash, randomBytes } from 'crypto';
 import * as https from 'https';
 import * as net from 'net';
@@ -88,12 +88,18 @@ function validateTransportUrl(rawUrl) {
   try {
     url = new URL(rawUrl);
   } catch {
-    throw new Error(`MCP transport: invalid URL "${rawUrl}"`);
+    throw new ConfigError({
+      message: `MCP transport: invalid URL "${rawUrl}"`,
+      code: "CONFIG_INVALID",
+      context: { field: "url", rawUrl }
+    });
   }
   if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new Error(
-      `MCP transport: unsupported protocol "${url.protocol}" \u2014 only http/https allowed`
-    );
+    throw new ConfigError({
+      message: `MCP transport: unsupported protocol "${url.protocol}" \u2014 only http/https allowed`,
+      code: "CONFIG_INVALID",
+      context: { field: "url", rawUrl, protocol: url.protocol }
+    });
   }
   const hostname = url.hostname;
   const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
@@ -101,25 +107,31 @@ function validateTransportUrl(rawUrl) {
   if (ipVersion === 4) {
     const parts = host.split(".").map(Number);
     if (parts[0] === 169 && parts[1] === 254) {
-      throw new Error(
-        `MCP transport: blocked link-local/IMDS address "${hostname}" \u2014 likely not a valid MCP server`
-      );
+      throw new ConfigError({
+        message: `MCP transport: blocked link-local/IMDS address "${hostname}" \u2014 likely not a valid MCP server`,
+        code: "CONFIG_INVALID",
+        context: { field: "url", rawUrl, hostname }
+      });
     }
   } else if (ipVersion === 6) {
     const lower = host.toLowerCase();
     const linkLocal = /^fe[89ab]/.test(lower);
     if (linkLocal || lower === "fd00:ec2::254") {
-      throw new Error(
-        `MCP transport: blocked link-local/IMDS address "${hostname}" \u2014 likely not a valid MCP server`
-      );
+      throw new ConfigError({
+        message: `MCP transport: blocked link-local/IMDS address "${hostname}" \u2014 likely not a valid MCP server`,
+        code: "CONFIG_INVALID",
+        context: { field: "url", rawUrl, hostname }
+      });
     }
   }
   if (url.protocol === "http:") {
     const isLoopback = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
     if (!isLoopback) {
-      throw new Error(
-        `MCP transport: http:// is only allowed for loopback addresses; use https:// for "${hostname}"`
-      );
+      throw new ConfigError({
+        message: `MCP transport: http:// is only allowed for loopback addresses; use https:// for "${hostname}"`,
+        code: "CONFIG_INVALID",
+        context: { field: "url", rawUrl, hostname, protocol: url.protocol }
+      });
     }
   }
 }
@@ -138,15 +150,21 @@ var SSEReader = class {
   }
   feed(chunk) {
     if (chunk.length > SSE_READER_MAX_BUFFER) {
-      throw new Error(
-        `SSE: chunk size ${chunk.length} exceeds max buffer ${SSE_READER_MAX_BUFFER} \u2014 refusing to accumulate`
-      );
+      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",
+        context: { phase: "feed", chunkLength: chunk.length, maxBuffer: SSE_READER_MAX_BUFFER }
+      });
     }
     this.buffer += chunk;
     if (this.buffer.length > SSE_READER_MAX_BUFFER) {
-      throw new Error(
-        `SSE: pending line exceeds ${SSE_READER_MAX_BUFFER} bytes \u2014 upstream is not framing events`
-      );
+      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",
+        context: { phase: "feed", bufferLength: this.buffer.length, maxBuffer: SSE_READER_MAX_BUFFER }
+      });
     }
     let idx = this.buffer.indexOf("\n");
     while (idx !== -1) {
@@ -168,9 +186,12 @@ var SSEReader = class {
     if (value.startsWith(" ")) value = value.slice(1);
     if (field === "event") ; else if (field === "data") {
       if (this.dataLines.length >= SSE_READER_MAX_DATA_LINES) {
-        throw new Error(
-          `SSE: exceeded ${SSE_READER_MAX_DATA_LINES} data lines per event \u2014 upstream is not sending blank-line delimiters`
-        );
+        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",
+          context: { phase: "processLine", dataLineCount: this.dataLines.length, maxDataLines: SSE_READER_MAX_DATA_LINES }
+        });
       }
       this.dataLines.push(value);
     }
@@ -259,15 +280,28 @@ function pickJsonRpcResult(text, id) {
 }
 function assertMatchingJsonRpcResult(data, expectedId, method) {
   if (!isJsonRpcResult(data)) {
-    throw new Error("Invalid JSON-RPC response: not a JSON-RPC 2.0 envelope");
+    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 !== void 0 && data.id !== expectedId) {
-    throw new Error(
-      `Invalid JSON-RPC response: id mismatch for ${method} (expected ${expectedId}, got ${data.id})`
-    );
+    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" }
+    });
   }
   if (data.id === void 0 && !method.startsWith("notifications/")) {
-    throw new Error(`Invalid JSON-RPC response: missing id for ${method}`);
+    throw new ToolError({
+      message: `Invalid JSON-RPC response: missing id for ${method}`,
+      code: "TOOL_EXECUTION_FAILED",
+      toolName: "mcp_transport_jsonrpc",
+      context: { method, expectedId, reason: "missing-id" }
+    });
   }
   return data;
 }
@@ -312,9 +346,11 @@ var BaseHTTPTransport = class {
     if (opts.tls) {
       if (opts.tls.rejectUnauthorized === false) {
         if (!isTlsUnsafeAllowed()) {
-          throw new Error(
-            `[mcp:${transportName}] TLS verification disabled \u2014 set WRONGSTACK_UNSAFE_MCP_TLS=1 to allow. Rejecting insecure configuration for ${this.url}.`
-          );
+          throw new ConfigError({
+            message: `[mcp:${transportName}] TLS verification disabled \u2014 set WRONGSTACK_UNSAFE_MCP_TLS=1 to allow. Rejecting insecure configuration for ${this.url}.`,
+            code: "CONFIG_INVALID",
+            context: { field: "tls.rejectUnauthorized", transportName, url: this.url }
+          });
         }
         console.error(
           `[mcp:${transportName}] \u26A0\uFE0F TLS verification DISABLED for ${this.url}. Network attacks are possible \u2014 only use on localhost.`
@@ -415,10 +451,20 @@ var SSETransport = class extends BaseHTTPTransport {
       this.applyTlsAgent(fetchOpts);
       const response = await fetch(sseUrl, fetchOpts);
       if (!response.ok) {
-        throw new Error(`SSE connect HTTP ${response.status}: ${response.statusText}`);
+        throw new ToolError({
+          message: `SSE connect HTTP ${response.status}: ${response.statusText}`,
+          code: "TOOL_EXECUTION_FAILED",
+          toolName: "mcp_transport_sse_connect",
+          context: { url: sseUrl, status: response.status, statusText: response.statusText }
+        });
       }
       if (!response.body) {
-        throw new Error("SSE response has no body");
+        throw new ToolError({
+          message: "SSE response has no body",
+          code: "TOOL_EXECUTION_FAILED",
+          toolName: "mcp_transport_sse_connect",
+          context: { url: sseUrl, reason: "missing-body" }
+        });
       }
       const textDecoder = new TextDecoder();
       const sseReader = new SSEReader();
@@ -442,7 +488,12 @@ var SSETransport = class extends BaseHTTPTransport {
         clientInfo: MCP_CONSTANTS.CLIENT_INFO
       });
       if (initRes.error) {
-        throw new Error(`initialize failed: ${initRes.error.message}`);
+        throw new ToolError({
+          message: `initialize failed: ${initRes.error.message}`,
+          code: "TOOL_EXECUTION_FAILED",
+          toolName: "mcp_transport_initialize",
+          context: { transport: "sse", url: this.url }
+        });
       }
       try {
         await this.httpPost("notifications/initialized", {});
@@ -512,16 +563,24 @@ 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 Error(`HTTP ${res.status}: ${snippet}`);
+        throw new ToolError({
+          message: `HTTP ${res.status}: ${snippet}`,
+          code: "TOOL_EXECUTION_FAILED",
+          toolName: method,
+          context: { transport: "sse", url: this.url, status: res.status }
+        });
       }
       let data;
       try {
         data = await res.json();
       } catch (err) {
-        throw new Error(
-          `Invalid JSON-RPC response: ${err instanceof Error ? err.message : "parse failed"}`,
-          { cause: err }
-        );
+        throw new ToolError({
+          message: `Invalid JSON-RPC response: ${err instanceof Error ? err.message : "parse failed"}`,
+          code: "TOOL_EXECUTION_FAILED",
+          toolName: method,
+          context: { transport: "sse", url: this.url, phase: "parse-json" },
+          cause: err
+        });
       }
       return assertMatchingJsonRpcResult(data, id, method);
     } finally {
@@ -530,7 +589,12 @@ var SSETransport = class extends BaseHTTPTransport {
   }
   async callTool(name, input) {
     if (this.state !== "connected") {
-      throw new Error(`SSE transport not connected (state=${this.state})`);
+      throw new ToolError({
+        message: `SSE transport not connected (state=${this.state})`,
+        code: "TOOL_EXECUTION_FAILED",
+        toolName: name,
+        context: { transport: "sse", state: this.state }
+      });
     }
     const res = await this.httpPost("tools/call", { name, arguments: input });
     if (res.error) {
@@ -562,16 +626,24 @@ var SSETransport = class extends BaseHTTPTransport {
     this.applyTlsAgent(fetchOpts);
     const res = await fetch(this.url, fetchOpts);
     if (!res.ok) {
-      throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+      throw new ToolError({
+        message: `HTTP ${res.status}: ${res.statusText}`,
+        code: "TOOL_EXECUTION_FAILED",
+        toolName: method,
+        context: { transport: "sse", url: this.url, status: res.status, statusText: res.statusText }
+      });
     }
     let data;
     try {
       data = await res.json();
     } catch (err) {
-      throw new Error(
-        `Invalid JSON-RPC response: ${err instanceof Error ? err.message : "parse failed"}`,
-        { cause: err }
-      );
+      throw new ToolError({
+        message: `Invalid JSON-RPC response: ${err instanceof Error ? err.message : "parse failed"}`,
+        code: "TOOL_EXECUTION_FAILED",
+        toolName: method,
+        context: { transport: "sse", url: this.url, phase: "parse-json" },
+        cause: err
+      });
     }
     const result = assertMatchingJsonRpcResult(data, id, method);
     timeoutSignal.dispose();