nuwax-mcp-stdio-proxy 1.4.3 → 1.4.4

package/dist/index.js

@@ -6809,12 +6809,13 @@ var logError = (msg) => log("ERROR", msg);
 
 // src/types.ts
 function isSseEntry(entry) {
-  if (!("url" in entry)) return false;
-  const e = entry;
-  return e.transport === "sse" || !e.transport && /\/sse(?:\?|$)/i.test(e.url);
+  return "url" in entry && entry.transport === "sse";
 }
 function isStreamableEntry(entry) {
-  return "url" in entry && typeof entry.url === "string" && !isSseEntry(entry);
+  return "url" in entry && typeof entry.url === "string" && entry.transport === "streamable-http";
+}
+function needsProtocolDetection(entry) {
+  return "url" in entry && typeof entry.url === "string" && !isSseEntry(entry) && !isStreamableEntry(entry);
 }
 
 // node_modules/zod/v3/helpers/util.js
@@ -23763,7 +23764,7 @@ var StdioServerTransport = class {
 
 // src/constants.ts
 var PKG_NAME = "nuwax-mcp-stdio-proxy";
-var PKG_VERSION = "1.4.3";
+var PKG_VERSION = "1.4.4";
 
 // src/shared.ts
 async function discoverTools(client) {
@@ -23838,6 +23839,81 @@ function filterTools(tools, filter) {
   return tools;
 }
 
+// src/detect.ts
+async function detectProtocol(url2, headers) {
+  logInfo(`Auto-detecting protocol for ${url2}...`);
+  try {
+    const reqHeaders = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      ...headers
+    };
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const res = await fetch(url2, {
+      method: "POST",
+      headers: reqHeaders,
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2025-03-26",
+          capabilities: {},
+          clientInfo: { name: "nuwax-mcp-detect", version: "1.0.0" }
+        }
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    const ct = res.headers.get("content-type") || "";
+    if (res.ok && (ct.includes("application/json") || ct.includes("text/event-stream"))) {
+      logInfo(`Detected streamable-http protocol for ${url2}`);
+      await res.text().catch(() => {
+      });
+      const sessionId = res.headers.get("mcp-session-id");
+      if (sessionId) {
+        fetch(url2, {
+          method: "DELETE",
+          headers: { "mcp-session-id": sessionId, ...headers },
+          signal: AbortSignal.timeout(5e3)
+        }).catch(() => {
+        });
+      }
+      return "stream";
+    }
+    await res.text().catch(() => {
+    });
+  } catch {
+  }
+  try {
+    const reqHeaders = {
+      Accept: "text/event-stream",
+      ...headers
+    };
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const res = await fetch(url2, {
+      method: "GET",
+      headers: reqHeaders,
+      signal: controller.signal
+    });
+    const ct = res.headers.get("content-type") || "";
+    if (ct.includes("text/event-stream")) {
+      clearTimeout(timeout);
+      logInfo(`Detected SSE protocol for ${url2}`);
+      controller.abort();
+      return "sse";
+    }
+    clearTimeout(timeout);
+    await res.text().catch(() => {
+    });
+  } catch {
+  }
+  logWarn(`Could not auto-detect protocol for ${url2}, defaulting to streamable-http`);
+  return "stream";
+}
+
 // src/modes/stdio.ts
 async function runStdio(config2, allowTools, denyTools) {
   const entries = Object.entries(config2.mcpServers);
@@ -23861,6 +23937,13 @@ async function runStdio(config2, allowTools, denyTools) {
         connected = await connectSse(id, entry);
       } else if (isStreamableEntry(entry)) {
         connected = await connectStreamable(id, entry);
+      } else if (needsProtocolDetection(entry)) {
+        const detected = await detectProtocol(entry.url, buildRequestHeaders(entry));
+        if (detected === "sse") {
+          connected = await connectSse(id, { ...entry, transport: "sse" });
+        } else {
+          connected = await connectStreamable(id, entry);
+        }
       } else {
         connected = await connectStdio(id, entry, baseEnv);
       }
@@ -23938,81 +24021,6 @@ async function runStdio(config2, allowTools, denyTools) {
   });
 }
 
-// src/detect.ts
-async function detectProtocol(url2, headers) {
-  logInfo(`Auto-detecting protocol for ${url2}...`);
-  try {
-    const reqHeaders = {
-      "Content-Type": "application/json",
-      Accept: "application/json, text/event-stream",
-      ...headers
-    };
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
-    const res = await fetch(url2, {
-      method: "POST",
-      headers: reqHeaders,
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        id: 1,
-        method: "initialize",
-        params: {
-          protocolVersion: "2025-03-26",
-          capabilities: {},
-          clientInfo: { name: "nuwax-mcp-detect", version: "1.0.0" }
-        }
-      }),
-      signal: controller.signal
-    });
-    clearTimeout(timeout);
-    const ct = res.headers.get("content-type") || "";
-    if (res.ok && (ct.includes("application/json") || ct.includes("text/event-stream"))) {
-      logInfo(`Detected streamable-http protocol for ${url2}`);
-      await res.text().catch(() => {
-      });
-      const sessionId = res.headers.get("mcp-session-id");
-      if (sessionId) {
-        fetch(url2, {
-          method: "DELETE",
-          headers: { "mcp-session-id": sessionId, ...headers },
-          signal: AbortSignal.timeout(5e3)
-        }).catch(() => {
-        });
-      }
-      return "stream";
-    }
-    await res.text().catch(() => {
-    });
-  } catch {
-  }
-  try {
-    const reqHeaders = {
-      Accept: "text/event-stream",
-      ...headers
-    };
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
-    const res = await fetch(url2, {
-      method: "GET",
-      headers: reqHeaders,
-      signal: controller.signal
-    });
-    const ct = res.headers.get("content-type") || "";
-    if (ct.includes("text/event-stream")) {
-      clearTimeout(timeout);
-      logInfo(`Detected SSE protocol for ${url2}`);
-      controller.abort();
-      return "sse";
-    }
-    clearTimeout(timeout);
-    await res.text().catch(() => {
-    });
-  } catch {
-  }
-  logWarn(`Could not auto-detect protocol for ${url2}, defaulting to streamable-http`);
-  return "stream";
-}
-
 // src/modes/convert.ts
 async function runConvert(args) {
   let targetUrl;

package/dist/modes/stdio.js

@@ -4,11 +4,12 @@
  * Aggregates multiple MCP servers (stdio + streamable-http + SSE)
  * into a single stdio MCP endpoint.
  */
-import { isSseEntry, isStreamableEntry } from '../types.js';
+import { isSseEntry, isStreamableEntry, needsProtocolDetection } from '../types.js';
 import { logInfo, logWarn, logError } from '../logger.js';
-import { buildBaseEnv, connectStdio, connectStreamable, connectSse } from '../transport.js';
+import { buildBaseEnv, connectStdio, connectStreamable, connectSse, buildRequestHeaders } from '../transport.js';
 import { discoverTools, createToolProxyServer, setupGracefulShutdown } from '../shared.js';
 import { filterTools } from '../filter.js';
+import { detectProtocol } from '../detect.js';
 export async function runStdio(config, allowTools, denyTools) {
     const entries = Object.entries(config.mcpServers);
     if (entries.length === 0) {
@@ -32,6 +33,16 @@ export async function runStdio(config, allowTools, denyTools) {
             else if (isStreamableEntry(entry)) {
                 connected = await connectStreamable(id, entry);
             }
+            else if (needsProtocolDetection(entry)) {
+                // No explicit transport — probe the URL to determine protocol
+                const detected = await detectProtocol(entry.url, buildRequestHeaders(entry));
+                if (detected === 'sse') {
+                    connected = await connectSse(id, { ...entry, transport: 'sse' });
+                }
+                else {
+                    connected = await connectStreamable(id, entry);
+                }
+            }
             else {
                 connected = await connectStdio(id, entry, baseEnv);
             }

package/dist/types.d.ts

@@ -45,6 +45,8 @@ export interface SseServerEntry {
 export type McpServerEntry = StdioServerEntry | StreamableServerEntry | SseServerEntry;
 export declare function isSseEntry(entry: McpServerEntry): entry is SseServerEntry;
 export declare function isStreamableEntry(entry: McpServerEntry): entry is StreamableServerEntry;
+/** Check if URL entry has no explicit transport → needs auto-detection */
+export declare function needsProtocolDetection(entry: McpServerEntry): entry is StreamableServerEntry;
 /** @deprecated Use StreamableServerEntry instead */
 export type BridgeServerEntry = StreamableServerEntry;
 /** @deprecated Use StreamableServerEntry instead */

package/dist/types.js

@@ -2,16 +2,19 @@
  * Types for MCP server configuration
  */
 export function isSseEntry(entry) {
-    if (!('url' in entry))
-        return false;
-    const e = entry;
-    // Explicit transport: 'sse' or URL path contains /sse (auto-detect)
-    return e.transport === 'sse' || (!e.transport && /\/sse(?:\?|$)/i.test(e.url));
+    return 'url' in entry && entry.transport === 'sse';
 }
 export function isStreamableEntry(entry) {
     return ('url' in entry &&
         typeof entry.url === 'string' &&
-        !isSseEntry(entry));
+        entry.transport === 'streamable-http');
+}
+/** Check if URL entry has no explicit transport → needs auto-detection */
+export function needsProtocolDetection(entry) {
+    return ('url' in entry &&
+        typeof entry.url === 'string' &&
+        !isSseEntry(entry) &&
+        !isStreamableEntry(entry));
 }
 /** @deprecated Use isStreamableEntry instead */
 export const isBridgeEntry = isStreamableEntry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuwax-mcp-stdio-proxy",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "description": "TypeScript MCP proxy — aggregates multiple MCP servers (stdio + streamable-http + SSE) with convert & proxy modes",
   "type": "module",
   "bin": {