nuwax-mcp-stdio-proxy 1.3.1 → 1.4.0

package/dist/lib.d.ts

@@ -8,6 +8,12 @@ export { PersistentMcpBridge } from './bridge.js';
 export type { BridgeLogger } from './bridge.js';
 export { CustomStdioClientTransport } from './customStdio.js';
 export type { CustomStdioServerParameters } from './customStdio.js';
-export { buildBaseEnv, connectStdio, connectBridge } from './transport.js';
+export { buildBaseEnv, buildRequestHeaders, connectStdio, connectStreamable, connectSse, connectBridge, } from './transport.js';
 export type { ConnectedClient } from './transport.js';
-export type { StdioServerEntry, BridgeServerEntry, McpServerEntry, McpServersConfig } from './types.js';
+export type { StdioServerEntry, StreamableServerEntry, SseServerEntry, BridgeServerEntry, HttpServerEntry, McpServerEntry, McpServersConfig, } from './types.js';
+export { isSseEntry, isStreamableEntry, isBridgeEntry } from './types.js';
+export { filterTools } from './filter.js';
+export type { ToolFilter } from './filter.js';
+export { detectProtocol } from './detect.js';
+export { discoverTools, createToolProxyServer, setupGracefulShutdown } from './shared.js';
+export type { ToolResolver, ToolProxyServerOptions } from './shared.js';

package/dist/lib.js

@@ -6,4 +6,8 @@
  */
 export { PersistentMcpBridge } from './bridge.js';
 export { CustomStdioClientTransport } from './customStdio.js';
-export { buildBaseEnv, connectStdio, connectBridge } from './transport.js';
+export { buildBaseEnv, buildRequestHeaders, connectStdio, connectStreamable, connectSse, connectBridge, } from './transport.js';
+export { isSseEntry, isStreamableEntry, isBridgeEntry } from './types.js';
+export { filterTools } from './filter.js';
+export { detectProtocol } from './detect.js';
+export { discoverTools, createToolProxyServer, setupGracefulShutdown } from './shared.js';

package/dist/modes/convert.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mode: convert (remote URL → stdio)
+ *
+ * Connects to a single remote MCP service (SSE or Streamable HTTP)
+ * and exposes it as a stdio MCP endpoint. Supports tool filtering.
+ */
+import type { McpServersConfig } from '../types.js';
+export interface ConvertArgs {
+    url?: string;
+    config?: McpServersConfig;
+    name?: string;
+    protocol?: 'sse' | 'stream';
+    allowTools?: string[];
+    denyTools?: string[];
+}
+export declare function runConvert(args: ConvertArgs): Promise<void>;

package/dist/modes/convert.js

@@ -0,0 +1,117 @@
+/**
+ * Mode: convert (remote URL → stdio)
+ *
+ * Connects to a single remote MCP service (SSE or Streamable HTTP)
+ * and exposes it as a stdio MCP endpoint. Supports tool filtering.
+ */
+import { logInfo, logWarn, logError } from '../logger.js';
+import { connectStreamable, connectSse, buildRequestHeaders } from '../transport.js';
+import { filterTools } from '../filter.js';
+import { detectProtocol } from '../detect.js';
+import { discoverTools, createToolProxyServer, setupGracefulShutdown } from '../shared.js';
+export async function runConvert(args) {
+    // 1. Resolve the target URL and headers
+    let targetUrl;
+    let targetHeaders;
+    let protocolHint = args.protocol;
+    if (args.url) {
+        targetUrl = args.url;
+    }
+    else if (args.config) {
+        const serverEntries = Object.entries(args.config.mcpServers);
+        if (serverEntries.length === 0) {
+            logError('No servers found in config');
+            process.exit(1);
+        }
+        // If --name specified, find that entry; otherwise use the first entry
+        let selected;
+        if (args.name) {
+            const found = serverEntries.find(([id]) => id === args.name);
+            if (!found) {
+                logError(`Server "${args.name}" not found in config. Available: ${serverEntries.map(([id]) => id).join(', ')}`);
+                process.exit(1);
+            }
+            selected = found;
+        }
+        else {
+            if (serverEntries.length > 1) {
+                logWarn(`Multiple servers in config, using first: "${serverEntries[0][0]}". Use --name to select.`);
+            }
+            selected = serverEntries[0];
+        }
+        const [, entry] = selected;
+        if (!('url' in entry) || typeof entry.url !== 'string') {
+            logError('Selected server entry must have a "url" field for convert mode');
+            process.exit(1);
+        }
+        targetUrl = entry.url;
+        // Extract headers/authToken from entry
+        const httpEntry = entry;
+        targetHeaders = buildRequestHeaders(httpEntry);
+        // If entry has explicit transport, use it as protocol hint
+        if ('transport' in entry && entry.transport === 'sse' && !protocolHint) {
+            protocolHint = 'sse';
+        }
+    }
+    else {
+        logError('Either URL or --config is required');
+        process.exit(1);
+    }
+    // 2. Detect protocol
+    let protocol = protocolHint;
+    if (!protocol) {
+        protocol = await detectProtocol(targetUrl, targetHeaders);
+    }
+    logInfo(`Connecting to ${targetUrl} via ${protocol === 'sse' ? 'SSE' : 'Streamable HTTP'}...`);
+    // 3. Connect to the remote server
+    const entryId = 'remote';
+    let connected;
+    if (protocol === 'sse') {
+        const sseEntry = { url: targetUrl, transport: 'sse' };
+        if (targetHeaders)
+            sseEntry.headers = targetHeaders;
+        connected = await connectSse(entryId, sseEntry);
+    }
+    else {
+        const streamEntry = { url: targetUrl };
+        if (targetHeaders)
+            streamEntry.headers = targetHeaders;
+        connected = await connectStreamable(entryId, streamEntry);
+    }
+    const { client: remoteClient, cleanup } = connected;
+    // 4. Discover tools
+    const allTools = await discoverTools(remoteClient);
+    logInfo(`Remote server has ${allTools.length} tool(s)`);
+    // 5. Apply tool filtering
+    const toolFilter = {};
+    if (args.allowTools)
+        toolFilter.allowTools = new Set(args.allowTools);
+    if (args.denyTools)
+        toolFilter.denyTools = new Set(args.denyTools);
+    const filteredTools = filterTools(allTools, toolFilter);
+    const filteredNames = new Set(filteredTools.map((t) => t.name));
+    if (filteredTools.length !== allTools.length) {
+        logInfo(`After filtering: ${filteredTools.length} tool(s)`);
+    }
+    // 6. Create stdio MCP server that proxies to the remote client
+    const { server } = await createToolProxyServer({
+        tools: filteredTools,
+        resolveClient: (name) => filteredNames.has(name) ? remoteClient : undefined,
+    });
+    logInfo('Convert proxy running on stdio');
+    // Graceful shutdown
+    setupGracefulShutdown(async () => {
+        try {
+            await remoteClient.close();
+        }
+        catch { /* ignore */ }
+        try {
+            await cleanup();
+        }
+        catch { /* ignore */ }
+        try {
+            await server.close();
+        }
+        catch { /* ignore */ }
+    });
+}

package/dist/modes/proxy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Mode: proxy (Streamable HTTP server)
+ *
+ * Starts PersistentMcpBridge as a Streamable HTTP server,
+ * exposing stdio MCP servers over HTTP on a specified port.
+ */
+import type { McpServersConfig } from '../types.js';
+export interface ProxyArgs {
+    port: number;
+    config: McpServersConfig;
+}
+export declare function runProxy(args: ProxyArgs): Promise<void>;

package/dist/modes/proxy.js

@@ -0,0 +1,37 @@
+/**
+ * Mode: proxy (Streamable HTTP server)
+ *
+ * Starts PersistentMcpBridge as a Streamable HTTP server,
+ * exposing stdio MCP servers over HTTP on a specified port.
+ */
+import { logInfo, logWarn, logError } from '../logger.js';
+import { PersistentMcpBridge } from '../bridge.js';
+import { setupGracefulShutdown } from '../shared.js';
+export async function runProxy(args) {
+    const { port, config } = args;
+    // Filter to only stdio entries for PersistentMcpBridge
+    const stdioEntries = {};
+    for (const [id, entry] of Object.entries(config.mcpServers)) {
+        if (!('url' in entry)) {
+            stdioEntries[id] = entry;
+        }
+        else {
+            logWarn(`Skipping non-stdio server "${id}" in proxy mode (only stdio servers supported)`);
+        }
+    }
+    if (Object.keys(stdioEntries).length === 0) {
+        logError('No stdio servers found in config for proxy mode');
+        process.exit(1);
+    }
+    logInfo(`Starting proxy HTTP server on port ${port} with ${Object.keys(stdioEntries).length} server(s)...`);
+    const bridge = new PersistentMcpBridge({
+        info: (...a) => logInfo(a.map(String).join(' ')),
+        warn: (...a) => logWarn(a.map(String).join(' ')),
+        error: (...a) => logError(a.map(String).join(' ')),
+    });
+    await bridge.start(stdioEntries, { port });
+    logInfo(`Proxy HTTP server running on port ${port}`);
+    setupGracefulShutdown(async () => {
+        await bridge.stop();
+    });
+}

package/dist/modes/stdio.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mode: stdio aggregation
+ *
+ * Aggregates multiple MCP servers (stdio + streamable-http + SSE)
+ * into a single stdio MCP endpoint.
+ */
+import type { McpServersConfig } from '../types.js';
+export declare function runStdio(config: McpServersConfig): Promise<void>;

package/dist/modes/stdio.js

@@ -0,0 +1,95 @@
+/**
+ * Mode: stdio aggregation
+ *
+ * Aggregates multiple MCP servers (stdio + streamable-http + SSE)
+ * into a single stdio MCP endpoint.
+ */
+import { isSseEntry, isStreamableEntry } from '../types.js';
+import { logInfo, logWarn, logError } from '../logger.js';
+import { buildBaseEnv, connectStdio, connectStreamable, connectSse } from '../transport.js';
+import { discoverTools, createToolProxyServer, setupGracefulShutdown } from '../shared.js';
+export async function runStdio(config) {
+    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} server(s): ${entries.map(([id]) => id).join(', ')}`);
+    // ---- Phase 1: Connect to all MCP servers (stdio + streamable + sse) ----
+    const baseEnv = buildBaseEnv();
+    const clients = new Map();
+    const cleanups = new Map();
+    const toolToClient = new Map();
+    const toolToServer = new Map();
+    const toolsByName = new Map();
+    for (const [id, entry] of entries) {
+        try {
+            let connected;
+            if (isSseEntry(entry)) {
+                connected = await connectSse(id, entry);
+            }
+            else if (isStreamableEntry(entry)) {
+                connected = await connectStreamable(id, entry);
+            }
+            else {
+                connected = await connectStdio(id, entry, baseEnv);
+            }
+            const { client, cleanup } = connected;
+            clients.set(id, client);
+            cleanups.set(id, cleanup);
+            const allServerTools = await discoverTools(client);
+            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}`);
+            // Continue with remaining servers — partial startup is acceptable
+        }
+    }
+    if (clients.size === 0) {
+        logError('Failed to connect to any 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 } = await createToolProxyServer({
+        tools: aggregatedTools,
+        resolveClient: (name) => toolToClient.get(name),
+        errorLabel: (name) => `"${name}" (server: "${toolToServer.get(name) || 'unknown'}")`,
+    });
+    logInfo('Proxy server running on stdio');
+    // ---- Graceful shutdown ----
+    setupGracefulShutdown(async () => {
+        for (const [id, client] of clients) {
+            try {
+                await client.close();
+                logInfo(`Closed client "${id}"`);
+            }
+            catch (e) {
+                logError(`Failed to close client "${id}": ${e}`);
+            }
+        }
+        for (const [id, cleanup] of cleanups) {
+            try {
+                await cleanup();
+            }
+            catch (e) {
+                logError(`Failed cleanup for "${id}": ${e}`);
+            }
+        }
+        try {
+            await server.close();
+        }
+        catch {
+            // Ignore close errors during shutdown
+        }
+    });
+}

package/dist/shared.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared helpers — deduplicated logic used across modes
+ */
+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 type { Tool } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Discover all tools from a connected MCP client, handling pagination.
+ */
+export declare function discoverTools(client: Client): Promise<Tool[]>;
+/**
+ * Callback that resolves a tool name to the client that owns it.
+ * Returns undefined if the tool is unknown or filtered.
+ */
+export type ToolResolver = (toolName: string) => Client | undefined;
+export interface ToolProxyServerOptions {
+    /** Tools to expose via ListTools */
+    tools: Tool[];
+    /** Resolves a tool name to the upstream client */
+    resolveClient: ToolResolver;
+    /** Optional label for error logging (e.g. server name) */
+    errorLabel?: (toolName: string) => string;
+}
+/**
+ * Create a stdio MCP server that proxies tool calls to upstream clients.
+ *
+ * Sets up Server with ListTools + CallTool handlers, connects to a
+ * StdioServerTransport, and returns both for lifecycle management.
+ */
+export declare function createToolProxyServer(opts: ToolProxyServerOptions): Promise<{
+    server: Server;
+    transport: StdioServerTransport;
+}>;
+/**
+ * Register SIGINT/SIGTERM handlers that run a cleanup function once,
+ * then exit. Guards against double-invocation.
+ */
+export declare function setupGracefulShutdown(cleanupFn: () => Promise<void>): void;

package/dist/shared.js

@@ -0,0 +1,83 @@
+/**
+ * Shared helpers — deduplicated logic used across modes
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { logInfo, logError } from './logger.js';
+import { PKG_NAME, PKG_VERSION } from './constants.js';
+// ========== Tool Discovery ==========
+/**
+ * Discover all tools from a connected MCP client, handling pagination.
+ */
+export async function discoverTools(client) {
+    const tools = [];
+    let cursor;
+    do {
+        const page = await client.listTools(cursor ? { cursor } : undefined);
+        tools.push(...page.tools);
+        cursor = page.nextCursor;
+    } while (cursor);
+    return tools;
+}
+/**
+ * Create a stdio MCP server that proxies tool calls to upstream clients.
+ *
+ * Sets up Server with ListTools + CallTool handlers, connects to a
+ * StdioServerTransport, and returns both for lifecycle management.
+ */
+export async function createToolProxyServer(opts) {
+    const { tools, resolveClient, errorLabel } = opts;
+    const server = new Server({ name: PKG_NAME, version: PKG_VERSION }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: toolArgs } = request.params;
+        const client = resolveClient(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 label = errorLabel ? errorLabel(name) : `"${name}"`;
+            logError(`Tool ${label} call failed: ${e}`);
+            return {
+                content: [{ type: 'text', text: `Tool call failed: ${e}` }],
+                isError: true,
+            };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    return { server, transport };
+}
+// ========== Graceful Shutdown ==========
+/**
+ * Register SIGINT/SIGTERM handlers that run a cleanup function once,
+ * then exit. Guards against double-invocation.
+ */
+export function setupGracefulShutdown(cleanupFn) {
+    let isShuttingDown = false;
+    const shutdown = async (signal) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        logInfo(`Received ${signal}, shutting down...`);
+        try {
+            await cleanupFn();
+        }
+        catch (e) {
+            logError(`Shutdown cleanup error: ${e}`);
+        }
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+}

package/dist/transport.d.ts

@@ -1,8 +1,8 @@
 /**
- * Transport layer — connect to upstream MCP servers via stdio or bridge (HTTP)
+ * Transport layer — connect to upstream MCP servers via stdio, Streamable HTTP, or SSE
  */
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import type { StdioServerEntry, BridgeServerEntry } from './types.js';
+import type { StdioServerEntry, StreamableServerEntry, SseServerEntry } from './types.js';
 export interface ConnectedClient {
     client: Client;
     cleanup: () => Promise<void>;
@@ -11,16 +11,29 @@ export interface ConnectedClient {
  * Build a clean env for child processes (strips ELECTRON_RUN_AS_NODE)
  */
 export declare function buildBaseEnv(): Record<string, string>;
+/**
+ * Build HTTP headers from entry config (merge headers + authToken)
+ */
+export declare function buildRequestHeaders(entry: StreamableServerEntry | SseServerEntry): Record<string, string> | undefined;
 /**
  * Connect to a stdio MCP server (spawn child process)
  */
 export declare function connectStdio(id: string, entry: StdioServerEntry, baseEnv: Record<string, string>): Promise<ConnectedClient>;
 /**
- * Connect to a bridge MCP server (StreamableHTTP → PersistentMcpBridge)
+ * Connect to a Streamable HTTP MCP server
+ *
+ * Supports PersistentMcpBridge endpoints and any remote MCP service using
+ * the Streamable HTTP transport protocol.
+ */
+export declare function connectStreamable(id: string, entry: StreamableServerEntry): Promise<ConnectedClient>;
+/**
+ * Connect to an SSE MCP server
  *
- * Bridge connections target long-lived MCP servers managed by PersistentMcpBridge
- * in the Electron main process, accessed via HTTP endpoints.
+ * Uses the legacy SSE (Server-Sent Events) transport for MCP servers
+ * that don't support the newer Streamable HTTP protocol.
  */
-export declare function connectBridge(id: string, entry: BridgeServerEntry): Promise<ConnectedClient>;
-/** @deprecated Use connectBridge instead */
-export declare const connectHttp: typeof connectBridge;
+export declare function connectSse(id: string, entry: SseServerEntry): Promise<ConnectedClient>;
+/** @deprecated Use connectStreamable instead */
+export declare const connectBridge: typeof connectStreamable;
+/** @deprecated Use connectStreamable instead */
+export declare const connectHttp: typeof connectStreamable;

package/dist/transport.js

@@ -1,8 +1,9 @@
 /**
- * Transport layer — connect to upstream MCP servers via stdio or bridge (HTTP)
+ * Transport layer — connect to upstream MCP servers via stdio, Streamable HTTP, or SSE
  */
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { CustomStdioClientTransport } from './customStdio.js';
 import { logInfo } from './logger.js';
 /**
@@ -19,6 +20,19 @@ export function buildBaseEnv() {
     delete env.ELECTRON_RUN_AS_NODE;
     return env;
 }
+/**
+ * Build HTTP headers from entry config (merge headers + authToken)
+ */
+export function buildRequestHeaders(entry) {
+    const headers = {};
+    if (entry.headers) {
+        Object.assign(headers, entry.headers);
+    }
+    if (entry.authToken) {
+        headers['Authorization'] = `Bearer ${entry.authToken}`;
+    }
+    return Object.keys(headers).length > 0 ? headers : undefined;
+}
 /**
  * Connect to a stdio MCP server (spawn child process)
  */
@@ -52,14 +66,39 @@ export async function connectStdio(id, entry, baseEnv) {
     };
 }
 /**
- * Connect to a bridge MCP server (StreamableHTTP → PersistentMcpBridge)
+ * Connect to a Streamable HTTP MCP server
+ *
+ * Supports PersistentMcpBridge endpoints and any remote MCP service using
+ * the Streamable HTTP transport protocol.
+ */
+export async function connectStreamable(id, entry) {
+    logInfo(`Connecting to "${id}" (streamable-http): ${entry.url}`);
+    const headers = buildRequestHeaders(entry);
+    const url = new URL(entry.url);
+    const transport = new StreamableHTTPClientTransport(url, headers ? { requestInit: { headers } } : undefined);
+    const client = new Client({ name: `proxy-${id}`, version: '1.0.0' });
+    await client.connect(transport);
+    return {
+        client,
+        cleanup: async () => {
+            try {
+                await transport.close();
+            }
+            catch { /* ignore */ }
+        },
+    };
+}
+/**
+ * Connect to an SSE MCP server
  *
- * Bridge connections target long-lived MCP servers managed by PersistentMcpBridge
- * in the Electron main process, accessed via HTTP endpoints.
+ * Uses the legacy SSE (Server-Sent Events) transport for MCP servers
+ * that don't support the newer Streamable HTTP protocol.
  */
-export async function connectBridge(id, entry) {
-    logInfo(`Connecting to "${id}" (bridge): ${entry.url}`);
-    const transport = new StreamableHTTPClientTransport(new URL(entry.url));
+export async function connectSse(id, entry) {
+    logInfo(`Connecting to "${id}" (sse): ${entry.url}`);
+    const headers = buildRequestHeaders(entry);
+    const url = new URL(entry.url);
+    const transport = new SSEClientTransport(url, headers ? { requestInit: { headers } } : undefined);
     const client = new Client({ name: `proxy-${id}`, version: '1.0.0' });
     await client.connect(transport);
     return {
@@ -72,5 +111,7 @@ export async function connectBridge(id, entry) {
         },
     };
 }
-/** @deprecated Use connectBridge instead */
-export const connectHttp = connectBridge;
+/** @deprecated Use connectStreamable instead */
+export const connectBridge = connectStreamable;
+/** @deprecated Use connectStreamable instead */
+export const connectHttp = connectStreamable;

package/dist/types.d.ts

@@ -8,21 +8,39 @@ export interface StdioServerEntry {
     env?: Record<string, string>;
 }
 /**
- * Bridge 类型: 连接持久化 MCP Bridge (HTTP)
+ * Streamable HTTP 类型: 连接远程 MCP server (Streamable HTTP)
  *
- * 用于连接 PersistentMcpBridge 等长生命周期的 MCP server。
- * Bridge server 通过 StreamableHTTPClientTransport 访问，
- * 其生命周期独立于 proxy 进程。
+ * 用于连接 PersistentMcpBridge 等长生命周期的 MCP server，
+ * 或直接连接支持 Streamable HTTP 协议的远程 MCP 服务。
  */
-export interface BridgeServerEntry {
+export interface StreamableServerEntry {
     url: string;
+    transport?: 'streamable-http';
+    headers?: Record<string, string>;
+    authToken?: string;
 }
-/** @deprecated Use BridgeServerEntry instead */
-export type HttpServerEntry = BridgeServerEntry;
-export type McpServerEntry = StdioServerEntry | BridgeServerEntry;
-export declare function isBridgeEntry(entry: McpServerEntry): entry is BridgeServerEntry;
-/** @deprecated Use isBridgeEntry instead */
-export declare const isHttpEntry: typeof isBridgeEntry;
+/**
+ * SSE 类型: 连接远程 MCP server (Server-Sent Events)
+ *
+ * 用于连接支持 SSE 传输的远程 MCP 服务（旧版 MCP 协议）。
+ */
+export interface SseServerEntry {
+    url: string;
+    transport: 'sse';
+    headers?: Record<string, string>;
+    authToken?: string;
+}
+export type McpServerEntry = StdioServerEntry | StreamableServerEntry | SseServerEntry;
+export declare function isSseEntry(entry: McpServerEntry): entry is SseServerEntry;
+export declare function isStreamableEntry(entry: McpServerEntry): entry is StreamableServerEntry;
+/** @deprecated Use StreamableServerEntry instead */
+export type BridgeServerEntry = StreamableServerEntry;
+/** @deprecated Use StreamableServerEntry instead */
+export type HttpServerEntry = StreamableServerEntry;
+/** @deprecated Use isStreamableEntry instead */
+export declare const isBridgeEntry: typeof isStreamableEntry;
+/** @deprecated Use isStreamableEntry instead */
+export declare const isHttpEntry: typeof isStreamableEntry;
 export interface McpServersConfig {
     mcpServers: Record<string, McpServerEntry>;
 }

package/dist/types.js

@@ -1,8 +1,15 @@
 /**
  * Types for MCP server configuration
  */
-export function isBridgeEntry(entry) {
-    return 'url' in entry && typeof entry.url === 'string';
+export function isSseEntry(entry) {
+    return 'url' in entry && entry.transport === 'sse';
 }
-/** @deprecated Use isBridgeEntry instead */
-export const isHttpEntry = isBridgeEntry;
+export function isStreamableEntry(entry) {
+    return ('url' in entry &&
+        typeof entry.url === 'string' &&
+        !isSseEntry(entry));
+}
+/** @deprecated Use isStreamableEntry instead */
+export const isBridgeEntry = isStreamableEntry;
+/** @deprecated Use isStreamableEntry instead */
+export const isHttpEntry = isStreamableEntry;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuwax-mcp-stdio-proxy",
-  "version": "1.3.1",
-  "description": "TypeScript stdio MCP proxy — aggregates multiple MCP servers (stdio + bridge) into one",
+  "version": "1.4.0",
+  "description": "TypeScript MCP proxy — aggregates multiple MCP servers (stdio + streamable-http + SSE) with convert & proxy modes",
   "type": "module",
   "bin": {
     "nuwax-mcp-stdio-proxy": "./dist/index.js"