nuwax-mcp-stdio-proxy 1.4.3 → 1.4.5

package/dist/index.js

@@ -6785,12 +6785,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs2, exportName) {
+    function addFormats(ajv, list, fs3, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs2[f]);
+        ajv.addFormat(f, fs3[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -6798,6 +6798,9 @@ var require_dist = __commonJS({
   }
 });
 
+// src/index.ts
+import * as fs2 from "fs";
+
 // src/logger.ts
 function log(level, msg) {
   process.stderr.write(`[nuwax-mcp-proxy] ${level}: ${msg}
@@ -6809,12 +6812,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 +23767,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.5";
 
 // src/shared.ts
 async function discoverTools(client) {
@@ -23838,6 +23842,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 +23940,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 +24024,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;
@@ -25774,6 +25785,7 @@ function parseCliArgs() {
 }
 function parseStdioArgs(args) {
   let configJson;
+  let configFile;
   let allowTools;
   let denyTools;
   for (let i = 0; i < args.length; i++) {
@@ -25781,6 +25793,9 @@ function parseStdioArgs(args) {
     if (arg === "--config" && i + 1 < args.length) {
       i++;
       configJson = args[i];
+    } else if (arg === "--config-file" && i + 1 < args.length) {
+      i++;
+      configFile = args[i];
     } else if (arg === "--allow-tools" && i + 1 < args.length) {
       i++;
       allowTools = args[i].split(",").map((s) => s.trim()).filter(Boolean);
@@ -25789,16 +25804,21 @@ function parseStdioArgs(args) {
       denyTools = args[i].split(",").map((s) => s.trim()).filter(Boolean);
     }
   }
-  if (!configJson) {
-    logError("Missing --config argument");
+  if (!configJson && !configFile) {
+    logError("Missing --config or --config-file argument");
     logError(`Usage: nuwax-mcp-stdio-proxy --config '{"mcpServers":{...}}'`);
+    logError("   or: nuwax-mcp-stdio-proxy --config-file /path/to/config.json");
+    process.exit(1);
+  }
+  if (configJson && configFile) {
+    logError("Cannot use both --config and --config-file");
     process.exit(1);
   }
   if (allowTools && denyTools) {
     logError("Cannot use both --allow-tools and --deny-tools");
     process.exit(1);
   }
-  const config2 = parseConfigJson(configJson);
+  const config2 = configFile ? parseConfigFile(configFile) : parseConfigJson(configJson);
   return { mode: "stdio", config: config2, allowTools, denyTools };
 }
 function parseConvertArgs(args) {
@@ -25852,6 +25872,7 @@ function parseConvertArgs(args) {
 function parseProxyArgs(args) {
   let port;
   let config2;
+  let configFile;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--port" && i + 1 < args.length) {
@@ -25865,6 +25886,9 @@ function parseProxyArgs(args) {
     } else if (arg === "--config" && i + 1 < args.length) {
       i++;
       config2 = parseConfigJson(args[i]);
+    } else if (arg === "--config-file" && i + 1 < args.length) {
+      i++;
+      configFile = args[i];
     } else {
       logError(`Unknown argument: "${arg}"`);
       printProxyUsage();
@@ -25876,8 +25900,11 @@ function parseProxyArgs(args) {
     printProxyUsage();
     process.exit(1);
   }
+  if (configFile) {
+    config2 = parseConfigFile(configFile);
+  }
   if (!config2) {
-    logError("--config is required for proxy mode");
+    logError("--config or --config-file is required for proxy mode");
     printProxyUsage();
     process.exit(1);
   }
@@ -25895,13 +25922,29 @@ function parseConfigJson(json2) {
     process.exit(1);
   }
 }
+function parseConfigFile(filePath) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const config2 = JSON.parse(content);
+    if (!config2.mcpServers || typeof config2.mcpServers !== "object") {
+      throw new Error('config must contain a "mcpServers" object');
+    }
+    return config2;
+  } catch (e) {
+    logError(`Failed to read or parse config file "${filePath}": ${e}`);
+    process.exit(1);
+  }
+}
 function printUsage() {
   logError("Usage:");
   logError(`  nuwax-mcp-stdio-proxy --config '{"mcpServers":{...}}' [OPTIONS]  (stdio aggregation)`);
+  logError("  nuwax-mcp-stdio-proxy --config-file <FILE> [OPTIONS]             (stdio aggregation from file)");
   logError("  nuwax-mcp-stdio-proxy convert [URL] [OPTIONS]                    (remote \u2192 stdio)");
   logError("  nuwax-mcp-stdio-proxy proxy --port <PORT> --config '...'         (HTTP server)");
   logError("");
   logError("Options (stdio / convert):");
+  logError("  --config <JSON>                MCP config JSON string");
+  logError("  --config-file <FILE>           MCP config JSON file path");
   logError("  --allow-tools <TOOLS>          Tool whitelist (comma-separated)");
   logError("  --deny-tools <TOOLS>           Tool blacklist (comma-separated)");
 }
@@ -25920,6 +25963,7 @@ function printConvertUsage() {
 }
 function printProxyUsage() {
   logError(`Usage: nuwax-mcp-stdio-proxy proxy --port <PORT> --config '{"mcpServers":{...}}'`);
+  logError("   or: nuwax-mcp-stdio-proxy proxy --port <PORT> --config-file <FILE>");
 }
 async function main() {
   const args = parseCliArgs();

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.5",
   "description": "TypeScript MCP proxy — aggregates multiple MCP servers (stdio + streamable-http + SSE) with convert & proxy modes",
   "type": "module",
   "bin": {