mcpay/dist/server/stdio/start-stdio-server.js

SDK and CLI for MCPay functionality - MCP servers with payment capabilities

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createServerConnections = exports.startStdioServer = exports.ServerType = void 0;
const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
const index_js_2 = require("@modelcontextprotocol/sdk/server/index.js");
const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
const payment_http_transport_1 = require("../../mcp/payment-http-transport");
const proxy_server_1 = require("./proxy-server");
var ServerType;
(function (ServerType) {
    ServerType["HTTPStream"] = "HTTPStream";
    ServerType["Payment"] = "Payment";
})(ServerType || (exports.ServerType = ServerType = {}));
/**
 * Enhanced proxy server that connects to multiple MCP servers and exposes them via a stdio interface
 */
const startStdioServer = async ({ initStdioServer, initStreamClient, serverConnections, account, }) => {
    if (serverConnections.length === 0) {
        throw new Error("No server connections provided");
    }
    // Connect to all servers
    const connectedClients = [];
    for (const connection of serverConnections) {
        let transport;
        switch (connection.serverType) {
            case ServerType.Payment:
                if (!account) {
                    throw new Error("Account is required for Payment transport");
                }
                transport = (0, payment_http_transport_1.createPaymentTransport)(new URL(connection.url), account, connection.transportOptions);
                break;
            default:
                transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(connection.url), connection.transportOptions);
        }
        let streamClient;
        if (connection.client) {
            streamClient = connection.client;
        }
        else if (initStreamClient) {
            streamClient = await initStreamClient();
        }
        else {
            streamClient = new index_js_1.Client({
                name: "mcp-proxy",
                version: "1.0.0",
            }, {
                capabilities: {},
            });
        }
        await streamClient.connect(transport);
        connectedClients.push(streamClient);
    }
    // We know there's at least one client because we check at the start
    // TypeScript doesn't understand our check above, so we'll assert that connectedClients[0] exists
    const servers = [];
    for (const client of connectedClients) {
        const serverVersion = client.getServerVersion();
        const serverCapabilities = client.getServerCapabilities();
        // Create the stdio server
        const stdioServer = initStdioServer
            ? await initStdioServer()
            : new index_js_2.Server(serverVersion, {
                capabilities: serverCapabilities,
            });
        const stdioTransport = new stdio_js_1.StdioServerTransport();
        await stdioServer.connect(stdioTransport);
        // Set up proxies for all connected clients
        // Start with primary client
        await (0, proxy_server_1.proxyServer)({
            client,
            server: stdioServer,
            serverCapabilities,
        });
        // Set up any additional clients if needed
        // This is where you could add logic to distribute requests across servers
        // or handle specific capabilities from different servers
        servers.push(stdioServer);
    }
    return servers;
};
exports.startStdioServer = startStdioServer;
/**
 * Creates server connection configurations from a list of URLs
 */
const createServerConnections = (urls, serverType = ServerType.HTTPStream, transportOptions = {}) => {
    return urls.map(url => ({
        url,
        serverType,
        transportOptions,
    }));
};
exports.createServerConnections = createServerConnections;
//# sourceMappingURL=start-stdio-server.js.map