nuwax-mcp-stdio-proxy 1.1.2 → 1.1.5

package/README.md

@@ -0,0 +1,70 @@
+# nuwax-mcp-stdio-proxy
+
+TypeScript stdio MCP proxy — aggregates multiple MCP servers into a single stdio endpoint. Supports **stdio** (spawn child processes) and **bridge** (Streamable HTTP to a persistent MCP bridge).
+
+## Requirements
+
+- **Node.js** >= 22.0.0
+
+## Usage
+
+```bash
+nuwax-mcp-stdio-proxy --config '{"mcpServers":{...}}'
+```
+
+The proxy reads JSON from `--config` and runs as a stdio MCP server. Upstream servers can be:
+
+- **stdio**: `{ "command", "args?", "env?" }` — proxy spawns a child process and talks MCP over stdin/stdout.
+- **bridge**: `{ "url" }` — proxy connects via HTTP (Streamable HTTP) to a long-lived MCP bridge (e.g. Electron app’s PersistentMcpBridge).
+
+## Config format
+
+| Entry type | Shape | Description |
+|------------|--------|-------------|
+| **stdio** | `{ "command": string, "args"?: string[], "env"?: Record<string, string> }` | Spawn subprocess; MCP over stdio. |
+| **bridge** | `{ "url": string }` | Connect to MCP over HTTP (e.g. `http://127.0.0.1:PORT/mcp/<serverId>`). |
+
+Example:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed"]
+    },
+    "chrome-devtools": {
+      "url": "http://127.0.0.1:57278/mcp/chrome-devtools"
+    }
+  }
+}
+```
+
+- `filesystem` → stdio (child process).
+- `chrome-devtools` → bridge (HTTP to a persistent bridge).
+
+## Architecture
+
+```
+Agent / ACP engine (stdin/stdout)
+        ↕
+  nuwax-mcp-stdio-proxy (StdioServerTransport)
+        ├→ stdio upstream  → child process (StdioClientTransport)
+        └→ bridge upstream → StreamableHTTPClientTransport → PersistentMcpBridge HTTP
+```
+
+- **Downstream**: one stdio MCP server; the agent talks to the proxy over stdin/stdout.
+- **Upstream**: multiple backends — some are child processes (stdio), some are HTTP bridge endpoints. Tools from all upstreams are aggregated and exposed as one tool list.
+
+## Scripts
+
+| Command | Description |
+|---------|-------------|
+| `npm run build` | Compile TypeScript to `dist/`. |
+| `npm run test` | Run tests (Vitest). |
+| `npm run test:run` | Run tests once (no watch). |
+| `npm run test:coverage` | Run tests with coverage. |
+
+## License
+
+MIT

package/dist/customStdio.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Custom Stdio Transport — fixes Windows console popup issue
+ *
+ * The MCP SDK's StdioClientTransport sets:
+ *   windowsHide: process.platform === 'win32' && isElectron()
+ *
+ * But when running via ELECTRON_RUN_AS_NODE=1, isElectron() returns false,
+ * causing console popup windows on Windows.
+ *
+ * This custom transport always sets windowsHide: true on Windows.
+ */
+import { Readable } from 'stream';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+export interface CustomStdioServerParameters {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    stderr?: 'inherit' | 'pipe' | 'overlapped';
+    cwd?: string;
+}
+export declare class CustomStdioClientTransport implements Transport {
+    private _process;
+    private _readBuffer;
+    private _stderrStream;
+    private _serverParams;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(server: CustomStdioServerParameters);
+    start(): Promise<void>;
+    get stderr(): Readable | null;
+    get pid(): number | null;
+    private processReadBuffer;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+}

package/dist/customStdio.js

@@ -0,0 +1,200 @@
+/**
+ * Custom Stdio Transport — fixes Windows console popup issue
+ *
+ * The MCP SDK's StdioClientTransport sets:
+ *   windowsHide: process.platform === 'win32' && isElectron()
+ *
+ * But when running via ELECTRON_RUN_AS_NODE=1, isElectron() returns false,
+ * causing console popup windows on Windows.
+ *
+ * This custom transport always sets windowsHide: true on Windows.
+ */
+import { spawn } from 'child_process';
+import { PassThrough } from 'stream';
+import { serializeMessage } from '@modelcontextprotocol/sdk/shared/stdio.js';
+export class CustomStdioClientTransport {
+    _process;
+    _readBuffer = new ReadBuffer();
+    _stderrStream = null;
+    _serverParams;
+    onclose;
+    onerror;
+    onmessage;
+    constructor(server) {
+        this._serverParams = server;
+        if (server.stderr === 'pipe' || server.stderr === 'overlapped') {
+            this._stderrStream = new PassThrough();
+        }
+    }
+    async start() {
+        if (this._process) {
+            throw new Error('StdioClientTransport already started!');
+        }
+        return new Promise((resolve, reject) => {
+            this._process = spawn(this._serverParams.command, this._serverParams.args ?? [], {
+                env: {
+                    ...getDefaultEnvironment(),
+                    ...this._serverParams.env,
+                },
+                stdio: ['pipe', 'pipe', this._serverParams.stderr ?? 'inherit'],
+                shell: false,
+                windowsHide: true,
+                cwd: this._serverParams.cwd,
+            });
+            this._process.on('error', (error) => {
+                reject(error);
+                this.onerror?.(error);
+            });
+            this._process.on('spawn', () => {
+                resolve();
+            });
+            this._process.on('close', (_code) => {
+                this._process = undefined;
+                this.onclose?.();
+            });
+            this._process.stdin?.on('error', (error) => {
+                this.onerror?.(error);
+            });
+            this._process.stdout?.on('data', (chunk) => {
+                this._readBuffer.append(chunk);
+                this.processReadBuffer();
+            });
+            this._process.stdout?.on('error', (error) => {
+                this.onerror?.(error);
+            });
+            if (this._stderrStream && this._process.stderr) {
+                this._process.stderr.pipe(this._stderrStream);
+            }
+        });
+    }
+    get stderr() {
+        if (this._stderrStream) {
+            return this._stderrStream;
+        }
+        return this._process?.stderr ?? null;
+    }
+    get pid() {
+        return this._process?.pid ?? null;
+    }
+    processReadBuffer() {
+        while (true) {
+            try {
+                const message = this._readBuffer.readMessage();
+                if (message === null) {
+                    break;
+                }
+                this.onmessage?.(message);
+            }
+            catch (error) {
+                this.onerror?.(error);
+            }
+        }
+    }
+    async close() {
+        if (this._process) {
+            const processToClose = this._process;
+            this._process = undefined;
+            const closePromise = new Promise((resolve) => {
+                processToClose.once('close', () => {
+                    resolve();
+                });
+            });
+            try {
+                processToClose.stdin?.end();
+            }
+            catch {
+                // ignore
+            }
+            await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2000).unref())]);
+            if (processToClose.exitCode === null) {
+                try {
+                    processToClose.kill('SIGTERM');
+                }
+                catch {
+                    // ignore
+                }
+                await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2000).unref())]);
+            }
+            if (processToClose.exitCode === null) {
+                try {
+                    processToClose.kill('SIGKILL');
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        this._readBuffer.clear();
+    }
+    async send(message) {
+        return new Promise((resolve) => {
+            if (!this._process?.stdin) {
+                throw new Error('Not connected');
+            }
+            const json = serializeMessage(message);
+            if (this._process.stdin.write(json)) {
+                resolve();
+            }
+            else {
+                this._process.stdin.once('drain', resolve);
+            }
+        });
+    }
+}
+class ReadBuffer {
+    _buffer;
+    append(chunk) {
+        this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+    }
+    readMessage() {
+        if (!this._buffer) {
+            return null;
+        }
+        const separatorIndex = this._buffer.indexOf('\n');
+        if (separatorIndex === -1) {
+            return null;
+        }
+        const line = this._buffer.subarray(0, separatorIndex);
+        this._buffer = this._buffer.subarray(separatorIndex + 1);
+        try {
+            const obj = JSON.parse(line.toString('utf-8'));
+            return obj;
+        }
+        catch {
+            throw new Error('Failed to parse JSON-RPC message');
+        }
+    }
+    clear() {
+        this._buffer = undefined;
+    }
+}
+const DEFAULT_INHERITED_ENV_VARS = process.platform === 'win32'
+    ? [
+        'APPDATA',
+        'HOMEDRIVE',
+        'HOMEPATH',
+        'LOCALAPPDATA',
+        'PATH',
+        'PROCESSOR_ARCHITECTURE',
+        'SYSTEMDRIVE',
+        'SYSTEMROOT',
+        'TEMP',
+        'USERNAME',
+        'USERPROFILE',
+        'PROGRAMFILES',
+    ]
+    : ['HOME', 'LOGNAME', 'PATH', 'SHELL', 'TERM', 'USER'];
+function getDefaultEnvironment() {
+    const env = {};
+    for (const key of DEFAULT_INHERITED_ENV_VARS) {
+        const value = process.env[key];
+        if (value === undefined) {
+            continue;
+        }
+        if (value.startsWith('()')) {
+            continue;
+        }
+        env[key] = value;
+    }
+    return env;
+}

package/dist/transport.js

@@ -2,8 +2,8 @@
  * Transport layer — connect to upstream MCP servers via stdio or bridge (HTTP)
  */
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { CustomStdioClientTransport } from './customStdio.js';
 import { logInfo } from './logger.js';
 /**
  * Build a clean env for child processes (strips ELECTRON_RUN_AS_NODE)
@@ -24,10 +24,11 @@ export function buildBaseEnv() {
  */
 export async function connectStdio(id, entry, baseEnv) {
     logInfo(`Connecting to "${id}" (stdio): ${entry.command} ${(entry.args || []).join(' ')}`);
-    const transport = new StdioClientTransport({
+    const transport = new CustomStdioClientTransport({
         command: entry.command,
         args: entry.args || [],
         env: { ...baseEnv, ...(entry.env || {}) },
+        stderr: 'pipe',
     });
     // Attach stderr listener BEFORE connect to catch early child errors
     if (transport.stderr) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuwax-mcp-stdio-proxy",
-  "version": "1.1.2",
+  "version": "1.1.5",
   "description": "TypeScript stdio MCP proxy — aggregates multiple MCP servers (stdio + bridge) into one",
   "type": "module",
   "bin": {