@modelcontextprotocol/inspector 1.0.1 → 2.0.0-rc.2

package/server/build/index.js

@@ -1,889 +0,0 @@
-#!/usr/bin/env node
-import cors from "cors";
-import { parseArgs } from "node:util";
-import { parse as shellParseArgs } from "shell-quote";
-import nodeFetch, { Headers as NodeHeaders } from "node-fetch";
-// Type-compatible wrappers for node-fetch to work with browser-style types
-const fetch = nodeFetch;
-const Headers = NodeHeaders;
-import { SSEClientTransport, SseError, } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport, StreamableHTTPError, } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import express from "express";
-import rateLimit from "express-rate-limit";
-import { findActualExecutable } from "spawn-rx";
-import mcpProxy from "./mcpProxy.js";
-import { randomUUID, randomBytes, timingSafeEqual } from "node:crypto";
-import { lookup as dnsLookup } from "node:dns/promises";
-import { isIP } from "node:net";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-import { readFileSync } from "fs";
-const DEFAULT_MCP_PROXY_LISTEN_PORT = "6277";
-const sandboxRateLimiter = rateLimit({
-    windowMs: 15 * 60 * 1000, // 15 minutes
-    max: 100, // limit each IP to 100 /sandbox requests per windowMs
-});
-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: "" },
-        command: { type: "string", default: "" },
-        transport: { type: "string", default: "" },
-        "server-url": { type: "string", default: "" },
-    },
-});
-/**
- * Helper function to detect 401 Unauthorized errors from various transport types.
- * StreamableHTTPClientTransport throws a generic Error with "HTTP 401" in the message
- * when there's no authProvider configured, while SSEClientTransport throws SseError.
- */
-const is401Error = (error) => {
-    if (error instanceof SseError && error.code === 401)
-        return true;
-    if (error instanceof StreamableHTTPError && error.code === 401)
-        return true;
-    if (error instanceof Error &&
-        (error.message.includes("HTTP 401") || error.message.includes("(401)")))
-        return true;
-    return false;
-};
-/**
- * Sends a sanitized JSON error response to the client without exposing
- * stack traces or internal error details. The full error is expected to
- * have already been logged server-side via console.error.
- */
-const sendErrorResponse = (res, status, message) => {
-    res.status(status).json({ error: message });
-};
-/**
- * Prefer forwarding the upstream MCP 401 (WWW-Authenticate + body) so the browser
- * matches direct-mode OAuth behavior. Falls back to a generic 401 JSON response
- * when no upstream details were captured, to avoid leaking stack traces.
- */
-const sendProxiedUnauthorized = (res, headerHolder) => {
-    const captured = headerHolder?.lastUpstream401;
-    if (captured && headerHolder) {
-        if (captured.wwwAuthenticate) {
-            res.setHeader("WWW-Authenticate", captured.wwwAuthenticate);
-        }
-        res.status(401);
-        res.setHeader("Content-Type", captured.contentType);
-        res.send(captured.body);
-        delete headerHolder.lastUpstream401;
-        return;
-    }
-    sendErrorResponse(res, 401, "Unauthorized");
-};
-// Function to get HTTP headers.
-const getHttpHeaders = (req) => {
-    const headers = {};
-    // Iterate over all headers in the request
-    for (const key in req.headers) {
-        const lowerKey = key.toLowerCase();
-        // Check if the header is one we want to forward
-        if (lowerKey.startsWith("mcp-") ||
-            lowerKey === "authorization" ||
-            lowerKey === "last-event-id") {
-            // Exclude the proxy's own authentication header and the Client <-> Proxy session ID header
-            if (lowerKey !== "x-mcp-proxy-auth" && lowerKey !== "mcp-session-id") {
-                const value = req.headers[key];
-                if (typeof value === "string") {
-                    // If the value is a string, use it directly
-                    headers[key] = value;
-                }
-                else if (Array.isArray(value)) {
-                    // If the value is an array, use the last element
-                    const lastValue = value.at(-1);
-                    if (lastValue !== undefined) {
-                        headers[key] = lastValue;
-                    }
-                }
-                // If value is undefined, it's skipped, which is correct.
-            }
-        }
-    }
-    // Handle the custom auth header separately. We expect `x-custom-auth-header`
-    // to be a string containing the name of the actual authentication header.
-    const customAuthHeaderName = req.headers["x-custom-auth-header"];
-    if (typeof customAuthHeaderName === "string") {
-        const lowerCaseHeaderName = customAuthHeaderName.toLowerCase();
-        const value = req.headers[lowerCaseHeaderName];
-        if (typeof value === "string") {
-            headers[customAuthHeaderName] = value;
-        }
-        else if (Array.isArray(value)) {
-            // If the actual auth header was sent multiple times, use the last value.
-            const lastValue = value.at(-1);
-            if (lastValue !== undefined) {
-                headers[customAuthHeaderName] = lastValue;
-            }
-        }
-    }
-    // Handle multiple custom headers (new approach)
-    if (req.headers["x-custom-auth-headers"] !== undefined) {
-        try {
-            const customHeaderNames = JSON.parse(req.headers["x-custom-auth-headers"]);
-            if (Array.isArray(customHeaderNames)) {
-                customHeaderNames.forEach((headerName) => {
-                    const lowerCaseHeaderName = headerName.toLowerCase();
-                    if (req.headers[lowerCaseHeaderName] !== undefined) {
-                        const value = req.headers[lowerCaseHeaderName];
-                        headers[headerName] = Array.isArray(value)
-                            ? value[value.length - 1]
-                            : value;
-                    }
-                });
-            }
-        }
-        catch (error) {
-            console.warn("Failed to parse x-custom-auth-headers:", error);
-        }
-    }
-    return headers;
-};
-/**
- * Updates a headers object in-place, preserving the original Accept header.
- * This is necessary to ensure that transports holding a reference to the headers
- * object see the updates.
- * @param currentHeaders The headers object to update.
- * @param newHeaders The new headers to apply.
- */
-const updateHeadersInPlace = (currentHeaders, newHeaders) => {
-    // Preserve the Accept header, which is set at transport creation and
-    // is not present in subsequent client requests.
-    const accept = currentHeaders["Accept"];
-    // Clear the old headers and apply the new ones.
-    Object.keys(currentHeaders).forEach((key) => delete currentHeaders[key]);
-    Object.assign(currentHeaders, newHeaders);
-    // Restore the Accept header.
-    if (accept) {
-        currentHeaders["Accept"] = accept;
-    }
-};
-const app = express();
-app.use(cors());
-app.use((req, res, next) => {
-    res.header("Access-Control-Expose-Headers", "mcp-session-id, WWW-Authenticate");
-    next();
-});
-const webAppTransports = new Map(); // Web app transports by web app sessionId
-const serverTransports = new Map(); // Server Transports by web app sessionId
-const sessionHeaderHolders = new Map(); // For dynamic header updates
-// Use provided token from environment or generate a new one
-const sessionToken = process.env.MCP_PROXY_AUTH_TOKEN || randomBytes(32).toString("hex");
-const authDisabled = !!process.env.DANGEROUSLY_OMIT_AUTH;
-// Origin validation middleware to prevent DNS rebinding attacks
-const originValidationMiddleware = (req, res, next) => {
-    const origin = req.headers.origin;
-    // Default origins based on CLIENT_PORT or use environment variable
-    const clientPort = process.env.CLIENT_PORT || "6274";
-    const defaultOrigin = `http://localhost:${clientPort}`;
-    const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(",") || [
-        defaultOrigin,
-    ];
-    if (origin && !allowedOrigins.includes(origin)) {
-        console.error(`Invalid origin: ${origin}`);
-        res.status(403).json({
-            error: "Forbidden - invalid origin",
-            message: "Request blocked to prevent DNS rebinding attacks. Configure allowed origins via environment variable.",
-        });
-        return;
-    }
-    next();
-};
-const authMiddleware = (req, res, next) => {
-    if (authDisabled) {
-        return next();
-    }
-    const sendUnauthorized = () => {
-        res.status(401).json({
-            error: "Unauthorized",
-            message: "Authentication required. Use the session token shown in the console when starting the server.",
-        });
-    };
-    const authHeader = req.headers["x-mcp-proxy-auth"];
-    const authHeaderValue = Array.isArray(authHeader)
-        ? authHeader[0]
-        : authHeader;
-    if (!authHeaderValue || !authHeaderValue.startsWith("Bearer ")) {
-        sendUnauthorized();
-        return;
-    }
-    const providedToken = authHeaderValue.substring(7); // Remove 'Bearer ' prefix
-    const expectedToken = sessionToken;
-    // Convert to buffers for timing-safe comparison
-    const providedBuffer = Buffer.from(providedToken);
-    const expectedBuffer = Buffer.from(expectedToken);
-    // Check length first to prevent timing attacks
-    if (providedBuffer.length !== expectedBuffer.length) {
-        sendUnauthorized();
-        return;
-    }
-    // Perform timing-safe comparison
-    if (!timingSafeEqual(providedBuffer, expectedBuffer)) {
-        sendUnauthorized();
-        return;
-    }
-    next();
-};
-/**
- * Converts a Node.js ReadableStream to a web-compatible ReadableStream
- * This is necessary for the EventSource polyfill which expects web streams
- */
-const createWebReadableStream = (nodeStream) => {
-    let closed = false;
-    return new ReadableStream({
-        start(controller) {
-            nodeStream.on("data", (chunk) => {
-                if (!closed) {
-                    controller.enqueue(chunk);
-                }
-            });
-            nodeStream.on("end", () => {
-                if (!closed) {
-                    closed = true;
-                    controller.close();
-                }
-            });
-            nodeStream.on("error", (err) => {
-                if (!closed) {
-                    closed = true;
-                    controller.error(err);
-                }
-            });
-        },
-        cancel() {
-            closed = true;
-            nodeStream.destroy();
-        },
-    });
-};
-/**
- * Creates a `fetch` function that merges dynamic session headers with the
- * headers from the actual request, ensuring that request-specific headers like
- * `Content-Type` are preserved. For SSE requests, it also converts Node.js
- * streams to web-compatible streams.
- */
-const createCustomFetch = (headerHolder) => {
-    return async (input, init) => {
-        // Determine the headers from the original request/init.
-        // The SDK may pass a Request object or a URL and an init object.
-        const originalHeaders = input instanceof Request ? input.headers : init?.headers;
-        // Start with our dynamic session headers.
-        const finalHeaders = new Headers(headerHolder.headers);
-        // Merge the SDK's request-specific headers, letting them overwrite.
-        // This is crucial for preserving Content-Type on POST requests.
-        new Headers(originalHeaders).forEach((value, key) => {
-            finalHeaders.set(key, value);
-        });
-        // Convert Headers to a plain object for node-fetch compatibility
-        const headersObject = {};
-        finalHeaders.forEach((value, key) => {
-            headersObject[key] = value;
-        });
-        // Get the response from node-fetch (cast input and init to handle type differences)
-        const response = await fetch(input, { ...init, headers: headersObject });
-        if (response.status === 401) {
-            const wwwAuthenticate = response.headers.get("www-authenticate") ?? undefined;
-            const contentType = response.headers.get("content-type") ?? "application/json";
-            const body = await response.text();
-            headerHolder.lastUpstream401 = {
-                wwwAuthenticate,
-                body,
-                contentType,
-            };
-            const responseHeaders = {};
-            response.headers.forEach((value, key) => {
-                responseHeaders[key] = value;
-            });
-            return new Response(body, {
-                status: 401,
-                statusText: response.statusText,
-                headers: responseHeaders,
-            });
-        }
-        // Check if this is an SSE request by looking at the Accept header
-        const acceptHeader = finalHeaders.get("Accept");
-        const isSSE = acceptHeader?.includes("text/event-stream");
-        if (isSSE && response.body) {
-            // For SSE requests, we need to convert the Node.js stream to a web ReadableStream
-            // because the EventSource polyfill expects web-compatible streams
-            const webStream = createWebReadableStream(response.body);
-            // Create a new response with the web-compatible stream
-            // Convert node-fetch headers to plain object for web Response compatibility
-            const responseHeaders = {};
-            response.headers.forEach((value, key) => {
-                responseHeaders[key] = value;
-            });
-            return new Response(webStream, {
-                status: response.status,
-                statusText: response.statusText,
-                headers: responseHeaders,
-            });
-        }
-        // For non-SSE requests, return the response as-is (cast to handle type differences)
-        return response;
-    };
-};
-const createTransport = async (req) => {
-    const query = req.query;
-    console.log("Query parameters:", JSON.stringify(query));
-    const transportType = query.transportType;
-    if (transportType === "stdio") {
-        const command = query.command.trim();
-        const origArgs = shellParseArgs(query.args);
-        const queryEnv = query.env ? JSON.parse(query.env) : {};
-        const env = { ...defaultEnvironment, ...process.env, ...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();
-        return { transport };
-    }
-    else if (transportType === "sse") {
-        const url = query.url;
-        const headers = getHttpHeaders(req);
-        headers["Accept"] = "text/event-stream";
-        const headerHolder = { headers };
-        console.log(`SSE transport: url=${url}, headers=${JSON.stringify(headers)}`);
-        const transport = new SSEClientTransport(new URL(url), {
-            eventSourceInit: {
-                fetch: createCustomFetch(headerHolder),
-            },
-            requestInit: {
-                headers: headerHolder.headers,
-            },
-        });
-        await transport.start();
-        return { transport, headerHolder };
-    }
-    else if (transportType === "streamable-http") {
-        const headers = getHttpHeaders(req);
-        headers["Accept"] = "text/event-stream, application/json";
-        const headerHolder = { headers };
-        const transport = new StreamableHTTPClientTransport(new URL(query.url), {
-            // Pass a custom fetch to inject the latest headers on each request
-            fetch: createCustomFetch(headerHolder),
-        });
-        await transport.start();
-        return { transport, headerHolder };
-    }
-    else {
-        console.error(`Invalid transport type: ${transportType}`);
-        throw new Error("Invalid transport type specified");
-    }
-};
-app.get("/mcp", originValidationMiddleware, authMiddleware, async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    console.log(`Received GET message for sessionId ${sessionId}`);
-    const headerHolder = sessionHeaderHolders.get(sessionId);
-    if (headerHolder) {
-        updateHeadersInPlace(headerHolder.headers, getHttpHeaders(req));
-    }
-    try {
-        const transport = webAppTransports.get(sessionId);
-        if (!transport) {
-            res.status(404).end("Session not found");
-            return;
-        }
-        else {
-            await transport.handleRequest(req, res);
-        }
-    }
-    catch (error) {
-        console.error("Error in /mcp route:", error);
-        sendErrorResponse(res, 500, "Internal server error");
-    }
-});
-app.post("/mcp", originValidationMiddleware, authMiddleware, async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    if (sessionId) {
-        console.log(`Received POST message for sessionId ${sessionId}`);
-        const headerHolder = sessionHeaderHolders.get(sessionId);
-        if (headerHolder) {
-            updateHeadersInPlace(headerHolder.headers, getHttpHeaders(req));
-        }
-        try {
-            const transport = webAppTransports.get(sessionId);
-            if (!transport) {
-                res.status(404).end("Transport not found for sessionId " + sessionId);
-            }
-            else {
-                await transport.handleRequest(req, res);
-            }
-        }
-        catch (error) {
-            console.error("Error in /mcp route:", error);
-            sendErrorResponse(res, 500, "Internal server error");
-        }
-    }
-    else {
-        console.log("New StreamableHttp connection request");
-        let streamableHeaderHolder;
-        try {
-            const { transport: serverTransport, headerHolder } = await createTransport(req);
-            streamableHeaderHolder = headerHolder;
-            const webAppTransport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: randomUUID,
-                onsessioninitialized: (sessionId) => {
-                    webAppTransports.set(sessionId, webAppTransport);
-                    serverTransports.set(sessionId, serverTransport); // eslint-disable-line @typescript-eslint/no-non-null-assertion
-                    if (headerHolder) {
-                        sessionHeaderHolders.set(sessionId, headerHolder);
-                    }
-                    console.log("Client <-> Proxy  sessionId: " + sessionId);
-                },
-                onsessionclosed: (sessionId) => {
-                    webAppTransports.delete(sessionId);
-                    serverTransports.delete(sessionId);
-                    sessionHeaderHolders.delete(sessionId);
-                },
-            });
-            console.log("Created StreamableHttp client transport");
-            await webAppTransport.start();
-            mcpProxy({
-                transportToClient: webAppTransport,
-                transportToServer: serverTransport,
-                headerHolder,
-            });
-            await webAppTransport.handleRequest(req, res, req.body);
-        }
-        catch (error) {
-            if (is401Error(error)) {
-                console.error("Received 401 Unauthorized from MCP server:", error instanceof Error ? error.message : error);
-                sendProxiedUnauthorized(res, streamableHeaderHolder);
-                return;
-            }
-            console.error("Error in /mcp POST route:", error);
-            sendErrorResponse(res, 500, "Internal server error");
-        }
-    }
-});
-app.delete("/mcp", originValidationMiddleware, authMiddleware, async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    console.log(`Received DELETE message for sessionId ${sessionId}`);
-    if (sessionId) {
-        try {
-            const serverTransport = serverTransports.get(sessionId);
-            if (!serverTransport) {
-                res.status(404).end("Transport not found for sessionId " + sessionId);
-            }
-            else {
-                await serverTransport.terminateSession();
-                await serverTransport.close();
-                webAppTransports.delete(sessionId);
-                serverTransports.delete(sessionId);
-                sessionHeaderHolders.delete(sessionId);
-                console.log(`Transports removed for sessionId ${sessionId}`);
-            }
-            res.status(200).end();
-        }
-        catch (error) {
-            console.error("Error in /mcp route:", error);
-            sendErrorResponse(res, 500, "Internal server error");
-        }
-    }
-});
-app.get("/stdio", originValidationMiddleware, authMiddleware, async (req, res) => {
-    try {
-        console.log("New STDIO connection request");
-        const { transport: serverTransport } = await createTransport(req);
-        const proxyFullAddress = req.query.proxyFullAddress || "";
-        const prefix = proxyFullAddress || "";
-        const endpoint = `${prefix}/message`;
-        const webAppTransport = new SSEServerTransport(endpoint, res);
-        webAppTransports.set(webAppTransport.sessionId, webAppTransport);
-        console.log("Created client transport");
-        serverTransports.set(webAppTransport.sessionId, serverTransport);
-        console.log("Created server transport");
-        await webAppTransport.start();
-        serverTransport.stderr.on("data", (chunk) => {
-            if (chunk.toString().includes("MODULE_NOT_FOUND")) {
-                // Server command not found, remove transports
-                const message = "Command not found, transports removed";
-                webAppTransport.send({
-                    jsonrpc: "2.0",
-                    method: "notifications/message",
-                    params: {
-                        level: "emergency",
-                        logger: "proxy",
-                        data: {
-                            message,
-                        },
-                    },
-                });
-                webAppTransport.close();
-                serverTransport.close();
-                webAppTransports.delete(webAppTransport.sessionId);
-                serverTransports.delete(webAppTransport.sessionId);
-                sessionHeaderHolders.delete(webAppTransport.sessionId);
-                console.error(message);
-            }
-            else {
-                // Inspect message and attempt to assign a RFC 5424 Syslog Protocol level
-                let level;
-                let message = chunk.toString().trim();
-                let ucMsg = chunk.toString().toUpperCase();
-                if (ucMsg.includes("DEBUG")) {
-                    level = "debug";
-                }
-                else if (ucMsg.includes("INFO")) {
-                    level = "info";
-                }
-                else if (ucMsg.includes("NOTICE")) {
-                    level = "notice";
-                }
-                else if (ucMsg.includes("WARN")) {
-                    level = "warning";
-                }
-                else if (ucMsg.includes("ERROR")) {
-                    level = "error";
-                }
-                else if (ucMsg.includes("CRITICAL")) {
-                    level = "critical";
-                }
-                else if (ucMsg.includes("ALERT")) {
-                    level = "alert";
-                }
-                else if (ucMsg.includes("EMERGENCY")) {
-                    level = "emergency";
-                }
-                else if (ucMsg.includes("SIGINT")) {
-                    message = "SIGINT received. Server shutdown.";
-                    level = "emergency";
-                }
-                else if (ucMsg.includes("SIGHUP")) {
-                    message = "SIGHUP received. Server shutdown.";
-                    level = "emergency";
-                }
-                else if (ucMsg.includes("SIGTERM")) {
-                    message = "SIGTERM received. Server shutdown.";
-                    level = "emergency";
-                }
-                else {
-                    level = "info";
-                }
-                webAppTransport.send({
-                    jsonrpc: "2.0",
-                    method: "notifications/message",
-                    params: {
-                        level,
-                        logger: "stdio",
-                        data: {
-                            message,
-                        },
-                    },
-                });
-            }
-        });
-        mcpProxy({
-            transportToClient: webAppTransport,
-            transportToServer: serverTransport,
-        });
-    }
-    catch (error) {
-        if (is401Error(error)) {
-            console.error("Received 401 Unauthorized from MCP server. Authentication failure.");
-            sendProxiedUnauthorized(res, undefined);
-            return;
-        }
-        console.error("Error in /stdio route:", error);
-        sendErrorResponse(res, 500, "Internal server error");
-    }
-});
-app.get("/sse", originValidationMiddleware, authMiddleware, async (req, res) => {
-    let sseHeaderHolder;
-    try {
-        console.log("New SSE connection request. NOTE: The SSE transport is deprecated and has been replaced by StreamableHttp");
-        const { transport: serverTransport, headerHolder } = await createTransport(req);
-        sseHeaderHolder = headerHolder;
-        const proxyFullAddress = req.query.proxyFullAddress || "";
-        const prefix = proxyFullAddress || "";
-        const endpoint = `${prefix}/message`;
-        const webAppTransport = new SSEServerTransport(endpoint, res);
-        webAppTransports.set(webAppTransport.sessionId, webAppTransport);
-        console.log("Created client transport");
-        serverTransports.set(webAppTransport.sessionId, serverTransport); // eslint-disable-line @typescript-eslint/no-non-null-assertion
-        if (headerHolder) {
-            sessionHeaderHolders.set(webAppTransport.sessionId, headerHolder);
-        }
-        console.log("Created server transport");
-        await webAppTransport.start();
-        mcpProxy({
-            transportToClient: webAppTransport,
-            transportToServer: serverTransport,
-            headerHolder,
-        });
-    }
-    catch (error) {
-        if (is401Error(error)) {
-            console.error("Received 401 Unauthorized from MCP server. Authentication failure.");
-            sendProxiedUnauthorized(res, sseHeaderHolder);
-            return;
-        }
-        else if (error instanceof SseError && error.code === 404) {
-            console.error("Received 404 not found from MCP server. Does the MCP server support SSE?");
-            sendErrorResponse(res, 404, "MCP server returned 404. Does it support SSE?");
-            return;
-        }
-        else if (error instanceof Error &&
-            (error.message.includes("ECONNREFUSED") ||
-                (error.cause && String(error.cause).includes("ECONNREFUSED")))) {
-            console.error("Connection refused. Is the MCP server running?");
-            sendErrorResponse(res, 500, "Connection refused. Is the MCP server running?");
-            return;
-        }
-        console.error("Error in /sse route:", error);
-        sendErrorResponse(res, 500, "Internal server error");
-    }
-});
-app.post("/message", originValidationMiddleware, authMiddleware, async (req, res) => {
-    try {
-        const sessionId = req.query.sessionId;
-        console.log(`Received POST message for sessionId ${sessionId}`);
-        const headerHolder = sessionHeaderHolders.get(sessionId);
-        if (headerHolder) {
-            updateHeadersInPlace(headerHolder.headers, getHttpHeaders(req));
-        }
-        const transport = webAppTransports.get(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);
-        sendErrorResponse(res, 500, "Internal server error");
-    }
-});
-app.get("/health", (req, res) => {
-    res.json({
-        status: "ok",
-    });
-});
-// Raised when the /fetch proxy is asked to reach a disallowed target, so the
-// route can distinguish an SSRF rejection (403) from an upstream failure (500).
-class ProxyTargetError extends Error {
-}
-const MAX_PROXY_REDIRECTS = 5;
-// The /fetch proxy is used by the client to reach OAuth discovery/token
-// endpoints on the connected MCP server (bypassing browser CORS). Connecting
-// to loopback and RFC1918/private LAN hosts is a core use case (testing local
-// or self-hosted MCP servers), so those stay reachable. We only block
-// link-local addresses — 169.254.0.0/16 (the AWS/GCP/Azure/etc. cloud metadata
-// endpoint 169.254.169.254 lives here) and IPv6 link-local / the AWS IPv6 IMDS
-// address — which are never legitimate proxy targets and are the real SSRF
-// exfiltration vector.
-function isBlockedProxyAddress(ip) {
-    const kind = isIP(ip);
-    if (kind === 4) {
-        const parts = ip.split(".").map(Number);
-        // 169.254.0.0/16 — IPv4 link-local (incl. cloud metadata 169.254.169.254)
-        return parts[0] === 169 && parts[1] === 254;
-    }
-    if (kind === 6) {
-        const addr = ip.toLowerCase();
-        // IPv4-mapped IPv6 (::ffff:x). The WHATWG URL parser serializes the embedded
-        // IPv4 in hex (::ffff:a9fe:a9fe for 169.254.169.254), while DNS and other
-        // sources may use the dotted form (::ffff:169.254.169.254) — handle both by
-        // extracting the IPv4 and re-checking it.
-        const mapped = addr.match(/^::ffff:(.+)$/);
-        if (mapped) {
-            const tail = mapped[1];
-            if (isIP(tail) === 4) {
-                return isBlockedProxyAddress(tail);
-            }
-            const hex = tail.match(/^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
-            if (hex) {
-                const high = parseInt(hex[1], 16);
-                const low = parseInt(hex[2], 16);
-                return isBlockedProxyAddress(`${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`);
-            }
-        }
-        // fe80::/10 — IPv6 link-local
-        if (/^fe[89ab]/.test(addr)) {
-            return true;
-        }
-        // fd00:ec2::254 — AWS IPv6 instance metadata endpoint
-        return addr === "fd00:ec2::254";
-    }
-    return false;
-}
-// Resolves the target host and rejects it if any resolved address is a blocked
-// (link-local/metadata) address, mitigating SSRF including the DNS case where a
-// hostname resolves to the cloud metadata IP.
-async function assertSafeProxyTarget(parsedUrl) {
-    const host = parsedUrl.hostname.replace(/^\[|\]$/g, ""); // strip IPv6 brackets
-    let addresses;
-    if (isIP(host)) {
-        addresses = [host];
-    }
-    else {
-        try {
-            addresses = (await dnsLookup(host, { all: true })).map((r) => r.address);
-        }
-        catch {
-            throw new ProxyTargetError(`Could not resolve host: ${host}`);
-        }
-    }
-    if (addresses.length === 0) {
-        throw new ProxyTargetError(`Could not resolve host: ${host}`);
-    }
-    for (const address of addresses) {
-        if (isBlockedProxyAddress(address)) {
-            throw new ProxyTargetError(`Refusing to proxy request to blocked address (${address})`);
-        }
-    }
-}
-// Fetch that follows redirects manually so every hop's target is re-validated
-// against assertSafeProxyTarget — otherwise an allowed host could redirect the
-// proxy into a blocked internal/metadata address.
-async function safeProxyFetch(initialUrl, init) {
-    let currentUrl = new URL(initialUrl);
-    let method = init?.method ?? "GET";
-    let body = init?.body;
-    const headers = init?.headers ?? {};
-    for (let hop = 0; hop <= MAX_PROXY_REDIRECTS; hop++) {
-        if (!["http:", "https:"].includes(currentUrl.protocol)) {
-            throw new ProxyTargetError("Only http/https URLs are allowed");
-        }
-        await assertSafeProxyTarget(currentUrl);
-        const response = await fetch(currentUrl.toString(), {
-            method,
-            headers,
-            body,
-            redirect: "manual",
-        });
-        if (response.status >= 300 && response.status < 400) {
-            const location = response.headers.get("location");
-            if (!location) {
-                return response;
-            }
-            currentUrl = new URL(location, currentUrl);
-            // Mirror browser/fetch semantics: 301/302/303 downgrade to a bodyless GET.
-            if ([301, 302, 303].includes(response.status)) {
-                method = "GET";
-                body = undefined;
-            }
-            continue;
-        }
-        return response;
-    }
-    throw new ProxyTargetError("Too many redirects");
-}
-app.post("/fetch", express.json(), originValidationMiddleware, authMiddleware, async (req, res) => {
-    try {
-        const { url, init } = req.body;
-        if (typeof url !== "string" || url.length === 0) {
-            res.status(400).json({ error: "Missing or invalid url" });
-            return;
-        }
-        let parsedUrl;
-        try {
-            parsedUrl = new URL(url);
-        }
-        catch {
-            res.status(400).json({ error: "Invalid URL" });
-            return;
-        }
-        if (!["http:", "https:"].includes(parsedUrl.protocol)) {
-            res.status(400).json({ error: "Only http/https URLs are allowed" });
-            return;
-        }
-        let response;
-        try {
-            response = await safeProxyFetch(url, init);
-        }
-        catch (error) {
-            if (error instanceof ProxyTargetError) {
-                res.status(403).json({ error: error.message });
-                return;
-            }
-            throw error;
-        }
-        const responseBody = await response.text();
-        const headers = {};
-        response.headers.forEach((value, key) => {
-            headers[key] = value;
-        });
-        res.status(response.status).json({
-            ok: response.ok,
-            status: response.status,
-            statusText: response.statusText,
-            headers,
-            body: responseBody,
-        });
-    }
-    catch (error) {
-        console.error("Error in /fetch route:", error);
-        sendErrorResponse(res, 500, "Internal server error");
-    }
-});
-app.get("/config", originValidationMiddleware, authMiddleware, (req, res) => {
-    try {
-        res.json({
-            defaultEnvironment,
-            defaultCommand: values.command,
-            defaultArgs: values.args,
-            defaultTransport: values.transport,
-            defaultServerUrl: values["server-url"],
-        });
-    }
-    catch (error) {
-        console.error("Error in /config route:", error);
-        sendErrorResponse(res, 500, "Internal server error");
-    }
-});
-app.get("/sandbox", sandboxRateLimiter, (req, res) => {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const filePath = join(__dirname, "..", "static", "sandbox_proxy.html");
-    let sandboxHtml;
-    try {
-        sandboxHtml = readFileSync(filePath, "utf-8");
-    }
-    catch (e) {
-        sandboxHtml = "MCP Apps sandbox not loaded: " + e;
-    }
-    res.set("Cache-Control", "no-cache, no-store, max-age=0");
-    res.send(sandboxHtml);
-});
-const PORT = parseInt(process.env.SERVER_PORT || DEFAULT_MCP_PROXY_LISTEN_PORT, 10);
-const HOST = process.env.HOST || "localhost";
-const server = app.listen(PORT, HOST);
-server.on("listening", () => {
-    console.log(`\n⚠️  @modelcontextprotocol/inspector v1 is deprecated.\n` +
-        `    Upgrade:  npx @modelcontextprotocol/inspector@latest\n` +
-        `    v1 receives security fixes only.\n`);
-    console.log(`⚙️ Proxy server listening on ${HOST}:${PORT}`);
-    if (!authDisabled) {
-        console.log(`🔑 Session token: ${sessionToken}\n   ` +
-            `Use this token to authenticate requests or set DANGEROUSLY_OMIT_AUTH=true to disable auth`);
-    }
-    else {
-        console.log(`⚠️  WARNING: Authentication is disabled. This is not recommended.`);
-    }
-});
-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);
-});