@mcpflow.io/mcp-mcp-inspector/server/build/index.js

MCP服务器的视觉测试工具

#!/usr/bin/env node
import cors from "cors";
import { parseArgs } from "node:util";
import { parse as shellParseArgs } from "shell-quote";
import { SSEClientTransport, SseError, } from "@modelcontextprotocol/sdk/client/sse.js";
import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import express from "express";
import { findActualExecutable } from "spawn-rx";
import mcpProxy from "./mcpProxy.js";
const SSE_HEADERS_PASSTHROUGH = ["authorization"];
const defaultEnvironment = {
    ...getDefaultEnvironment(),
    ...(process.env.MCP_ENV_VARS ? JSON.parse(process.env.MCP_ENV_VARS) : {}),
};
const { values } = parseArgs({
    args: process.argv.slice(2),
    options: {
        env: { type: "string", default: "" },
        args: { type: "string", default: "" },
    },
});
const app = express();
app.use(cors());
let webAppTransports = [];
const createTransport = async (req) => {
    const query = req.query;
    console.log("Query parameters:", query);
    const transportType = query.transportType;
    if (transportType === "stdio") {
        const command = query.command;
        const origArgs = shellParseArgs(query.args);
        const queryEnv = query.env ? JSON.parse(query.env) : {};
        const env = { ...process.env, ...defaultEnvironment, ...queryEnv };
        const { cmd, args } = findActualExecutable(command, origArgs);
        console.log(`Stdio transport: command=${cmd}, args=${args}`);
        const transport = new StdioClientTransport({
            command: cmd,
            args,
            env,
            stderr: "pipe",
        });
        await transport.start();
        console.log("Spawned stdio transport");
        return transport;
    }
    else if (transportType === "sse") {
        const url = query.url;
        const headers = {
            Accept: "text/event-stream",
        };
        for (const key of SSE_HEADERS_PASSTHROUGH) {
            if (req.headers[key] === undefined) {
                continue;
            }
            const value = req.headers[key];
            headers[key] = Array.isArray(value) ? value[value.length - 1] : value;
        }
        console.log(`SSE transport: url=${url}, headers=${Object.keys(headers)}`);
        const transport = new SSEClientTransport(new URL(url), {
            eventSourceInit: {
                fetch: (url, init) => fetch(url, { ...init, headers }),
            },
            requestInit: {
                headers,
            },
        });
        await transport.start();
        console.log("Connected to SSE transport");
        return transport;
    }
    else {
        console.error(`Invalid transport type: ${transportType}`);
        throw new Error("Invalid transport type specified");
    }
};
let backingServerTransport;
app.get("/sse", async (req, res) => {
    try {
        console.log("New SSE connection");
        try {
            await backingServerTransport?.close();
            backingServerTransport = await createTransport(req);
        }
        catch (error) {
            if (error instanceof SseError && error.code === 401) {
                console.error("Received 401 Unauthorized from MCP server:", error.message);
                res.status(401).json(error);
                return;
            }
            throw error;
        }
        console.log("Connected MCP client to backing server transport");
        const webAppTransport = new SSEServerTransport("/message", res);
        console.log("Created web app transport");
        webAppTransports.push(webAppTransport);
        console.log("Created web app transport");
        await webAppTransport.start();
        if (backingServerTransport instanceof StdioClientTransport) {
            backingServerTransport.stderr.on("data", (chunk) => {
                webAppTransport.send({
                    jsonrpc: "2.0",
                    method: "notifications/stderr",
                    params: {
                        content: chunk.toString(),
                    },
                });
            });
        }
        mcpProxy({
            transportToClient: webAppTransport,
            transportToServer: backingServerTransport,
        });
        console.log("Set up MCP proxy");
    }
    catch (error) {
        console.error("Error in /sse route:", error);
        res.status(500).json(error);
    }
});
app.post("/message", async (req, res) => {
    try {
        const sessionId = req.query.sessionId;
        console.log(`Received message for sessionId ${sessionId}`);
        const transport = webAppTransports.find((t) => t.sessionId === sessionId);
        if (!transport) {
            res.status(404).end("Session not found");
            return;
        }
        await transport.handlePostMessage(req, res);
    }
    catch (error) {
        console.error("Error in /message route:", error);
        res.status(500).json(error);
    }
});
app.get("/config", (req, res) => {
    try {
        res.json({
            defaultEnvironment,
            defaultCommand: values.env,
            defaultArgs: values.args,
        });
    }
    catch (error) {
        console.error("Error in /config route:", error);
        res.status(500).json(error);
    }
});
const PORT = process.env.PORT || 6277;
const server = app.listen(PORT);
server.on("listening", () => {
    console.log(`⚙️ Proxy server listening on port ${PORT}`);
});
server.on("error", (err) => {
    if (err.message.includes(`EADDRINUSE`)) {
        console.error(`❌  Proxy Server PORT IS IN USE at port ${PORT} ❌ `);
    }
    else {
        console.error(err.message);
    }
    process.exit(1);
});