nuwax-mcp-stdio-proxy 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * nuwax-mcp-stdio-proxy
+ *
+ * A pure TypeScript stdio MCP proxy that aggregates multiple child MCP servers
+ * into a single MCP server endpoint. Eliminates HTTP/port management and
+ * avoids Windows console popup issues when invoked via Node.js directly.
+ *
+ * Usage:
+ *   nuwax-mcp-stdio-proxy --config '{"mcpServers":{"name":{"command":"...","args":["..."]}}}'
+ *
+ * Architecture:
+ *   Agent Engine (stdin/stdout)  ←→  This Proxy (StdioServerTransport)
+ *                                         ├→ Child MCP Server A (StdioClientTransport)
+ *                                         ├→ Child MCP Server B (StdioClientTransport)
+ *                                         └→ ...
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+/**
+ * nuwax-mcp-stdio-proxy
+ *
+ * A pure TypeScript stdio MCP proxy that aggregates multiple child MCP servers
+ * into a single MCP server endpoint. Eliminates HTTP/port management and
+ * avoids Windows console popup issues when invoked via Node.js directly.
+ *
+ * Usage:
+ *   nuwax-mcp-stdio-proxy --config '{"mcpServers":{"name":{"command":"...","args":["..."]}}}'
+ *
+ * Architecture:
+ *   Agent Engine (stdin/stdout)  ←→  This Proxy (StdioServerTransport)
+ *                                         ├→ Child MCP Server A (StdioClientTransport)
+ *                                         ├→ Child MCP Server B (StdioClientTransport)
+ *                                         └→ ...
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+// ========== Logging (stderr only — stdout is MCP JSON-RPC channel) ==========
+function log(level, msg) {
+    process.stderr.write(`[nuwax-mcp-proxy] ${level}: ${msg}\n`);
+}
+const logInfo = (msg) => log('INFO', msg);
+const logWarn = (msg) => log('WARN', msg);
+const logError = (msg) => log('ERROR', msg);
+// ========== CLI Argument Parsing ==========
+function parseConfig() {
+    const args = process.argv.slice(2);
+    const idx = args.indexOf('--config');
+    if (idx === -1 || idx + 1 >= args.length) {
+        logError('Missing --config argument');
+        logError('Usage: nuwax-mcp-stdio-proxy --config \'{"mcpServers":{...}}\'');
+        process.exit(1);
+    }
+    try {
+        const config = JSON.parse(args[idx + 1]);
+        if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+            throw new Error('config must contain a "mcpServers" object');
+        }
+        return config;
+    }
+    catch (e) {
+        logError(`Failed to parse --config JSON: ${e}`);
+        process.exit(1);
+    }
+}
+// ========== Build Clean Environment for Child Processes ==========
+function buildBaseEnv() {
+    const env = {};
+    // Copy current process.env, filtering out undefined values
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+            env[key] = value;
+        }
+    }
+    // Remove ELECTRON_RUN_AS_NODE — child MCP servers should run normally,
+    // not as Electron Node.js instances
+    delete env.ELECTRON_RUN_AS_NODE;
+    return env;
+}
+// ========== Main ==========
+async function main() {
+    const config = parseConfig();
+    const entries = Object.entries(config.mcpServers);
+    if (entries.length === 0) {
+        logError('No MCP servers configured in mcpServers');
+        process.exit(1);
+    }
+    logInfo(`Starting proxy with ${entries.length} child server(s): ${entries.map(([id]) => id).join(', ')}`);
+    // ---- Phase 1: Connect to all child MCP servers ----
+    // Build base env once — per-server env is merged on top
+    const baseEnv = buildBaseEnv();
+    const clients = new Map();
+    const toolToClient = new Map();
+    const toolToServer = new Map();
+    const toolsByName = new Map();
+    for (const [id, entry] of entries) {
+        let transport = null;
+        try {
+            logInfo(`Connecting to "${id}": ${entry.command} ${(entry.args || []).join(' ')}`);
+            transport = new StdioClientTransport({
+                command: entry.command,
+                args: entry.args || [],
+                env: { ...baseEnv, ...(entry.env || {}) },
+                // stderr defaults to 'pipe' in the SDK; child errors captured via transport.stderr
+            });
+            // Attach stderr listener BEFORE connect to catch early child errors
+            // (SDK returns a PassThrough stream immediately for this purpose)
+            if (transport.stderr) {
+                transport.stderr.on('data', (chunk) => {
+                    const text = chunk.toString().trim();
+                    if (text) {
+                        process.stderr.write(`[child:${id}] ${text}\n`);
+                    }
+                });
+            }
+            const client = new Client({ name: `proxy-${id}`, version: '1.0.0' });
+            await client.connect(transport);
+            clients.set(id, client);
+            // Discover tools from this child server (handle pagination)
+            const allServerTools = [];
+            let cursor;
+            do {
+                const page = await client.listTools(cursor ? { cursor } : undefined);
+                allServerTools.push(...page.tools);
+                cursor = page.nextCursor;
+            } while (cursor);
+            logInfo(`Server "${id}": ${allServerTools.length} tool(s)${allServerTools.length > 0 ? ' — ' + allServerTools.map((t) => t.name).join(', ') : ''}`);
+            for (const tool of allServerTools) {
+                if (toolToClient.has(tool.name)) {
+                    logWarn(`Tool "${tool.name}" from "${id}" shadows existing tool from "${toolToServer.get(tool.name)}"`);
+                }
+                toolToClient.set(tool.name, client);
+                toolToServer.set(tool.name, id);
+                toolsByName.set(tool.name, tool);
+            }
+        }
+        catch (e) {
+            logError(`Failed to connect to server "${id}": ${e}`);
+            // Clean up transport to prevent child process leak
+            if (transport) {
+                try {
+                    await transport.close();
+                }
+                catch { /* ignore */ }
+            }
+            // Continue with remaining servers — partial startup is acceptable
+        }
+    }
+    if (clients.size === 0) {
+        logError('Failed to connect to any child MCP server');
+        process.exit(1);
+    }
+    const aggregatedTools = Array.from(toolsByName.values());
+    logInfo(`Aggregated ${aggregatedTools.length} unique tool(s) from ${clients.size} server(s)`);
+    // ---- Phase 2: Create the aggregating MCP server ----
+    const server = new Server({ name: 'nuwax-mcp-stdio-proxy', version: '1.0.0' }, { capabilities: { tools: {} } });
+    // tools/list → return all aggregated tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: aggregatedTools };
+    });
+    // tools/call → route to the correct child server
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: toolArgs } = request.params;
+        const client = toolToClient.get(name);
+        if (!client) {
+            return {
+                content: [{ type: 'text', text: `Unknown tool: "${name}"` }],
+                isError: true,
+            };
+        }
+        try {
+            const result = await client.callTool({ name, arguments: toolArgs });
+            return result;
+        }
+        catch (e) {
+            const serverName = toolToServer.get(name) || 'unknown';
+            logError(`Tool "${name}" (server: "${serverName}") call failed: ${e}`);
+            return {
+                content: [{ type: 'text', text: `Tool call failed: ${e}` }],
+                isError: true,
+            };
+        }
+    });
+    // ---- Phase 3: Start stdio transport ----
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logInfo('Proxy server running on stdio');
+    // ---- Graceful shutdown ----
+    let isShuttingDown = false;
+    const shutdown = async (signal) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        logInfo(`Received ${signal}, shutting down...`);
+        for (const [id, client] of clients) {
+            try {
+                await client.close();
+                logInfo(`Closed child client "${id}"`);
+            }
+            catch (e) {
+                logError(`Failed to close child client "${id}": ${e}`);
+            }
+        }
+        try {
+            await server.close();
+        }
+        catch {
+            // Ignore close errors during shutdown
+        }
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+}
+process.on('unhandledRejection', (reason) => {
+    logError(`Unhandled rejection: ${reason}`);
+    process.exit(1);
+});
+main().catch((error) => {
+    logError(`Fatal error: ${error}`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "nuwax-mcp-stdio-proxy",
+  "version": "1.0.0",
+  "description": "TypeScript stdio MCP proxy — aggregates multiple child MCP servers into one",
+  "type": "module",
+  "bin": {
+    "nuwax-mcp-stdio-proxy": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "license": "MIT"
+}