mcp-server-madeonsol 1.27.1 → 2.0.0

package/dist/http-security.d.ts

@@ -0,0 +1,14 @@
+import { type IncomingMessage, type ServerResponse } from "node:http";
+export declare const MAX_BODY_BYTES: number;
+export declare const BODY_TIMEOUT_MS = 10000;
+export declare const MAX_ACTIVE_REQUESTS = 16;
+export interface HttpConfig {
+    host: "127.0.0.1" | "::1";
+    port: number;
+    allowedHosts: string[];
+    tokenDigest: Buffer;
+}
+export declare function readHttpConfig(env?: NodeJS.ProcessEnv): HttpConfig;
+/** Bounded body ingestion; callers must authenticate before invoking this. */
+export declare function readJsonBody(req: IncomingMessage, maxBytes?: number, timeoutMs?: number): Promise<unknown>;
+export declare function createPrivateHttpServer(config: HttpConfig, handle: (req: IncomingMessage, res: ServerResponse, body?: unknown) => Promise<void>): import("http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/dist/http-security.js

@@ -0,0 +1,180 @@
+// Keep this standalone-package helper identical in both MCP packages.
+// HTTP is a private, single-operator adapter. Public/multi-user hosting is
+// intentionally unsupported until credentials can be scoped per principal.
+import { createServer } from "node:http";
+import { createHash, timingSafeEqual } from "node:crypto";
+export const MAX_BODY_BYTES = 256 * 1024;
+export const BODY_TIMEOUT_MS = 10_000;
+export const MAX_ACTIVE_REQUESTS = 16;
+export function readHttpConfig(env = process.env) {
+    const host = env.HOST || "127.0.0.1";
+    if (host !== "127.0.0.1" && host !== "::1") {
+        throw new Error("HTTP MCP requires HOST=127.0.0.1 or ::1; public binding is unsupported. Use stdio for local clients.");
+    }
+    const portText = env.PORT || "3100";
+    const port = Number(portText);
+    if (!/^\d+$/.test(portText) || !Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error("HTTP MCP requires a valid PORT between 1 and 65535.");
+    }
+    if (env.SVM_PRIVATE_KEY || env.RHC_PAYER_KEY) {
+        throw new Error("HTTP MCP cannot expose a payment signer. Remove wallet credentials or use stdio.");
+    }
+    if (!env.MADEONSOL_API_KEY?.startsWith("msk_")) {
+        throw new Error("HTTP MCP requires the operator's MADEONSOL_API_KEY.");
+    }
+    const token = env.MCP_HTTP_TOKEN || "";
+    if (!/^[A-Za-z0-9_-]{32,256}$/.test(token) || token === env.MADEONSOL_API_KEY) {
+        throw new Error("HTTP MCP requires a separate random MCP_HTTP_TOKEN (32–256 base64url characters).");
+    }
+    const authority = host === "::1" ? `[::1]:${port}` : `${host}:${port}`;
+    return {
+        host, port, allowedHosts: [authority, `localhost:${port}`],
+        tokenDigest: createHash("sha256").update(token).digest(),
+    };
+}
+class HttpFailure extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+function fail(res, status, message) {
+    if (res.headersSent) {
+        res.destroy();
+        return;
+    }
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-store",
+        "Connection": "close",
+        ...(status === 401 ? { "WWW-Authenticate": 'Bearer realm="private-mcp"' } : {}),
+    });
+    res.end(JSON.stringify({ error: message }));
+}
+function headerCount(req, name) {
+    let count = 0;
+    for (let i = 0; i < req.rawHeaders.length; i += 2) {
+        if (req.rawHeaders[i].toLowerCase() === name)
+            count++;
+    }
+    return count;
+}
+function authorize(req, res, config) {
+    const remote = req.socket.remoteAddress;
+    if ((remote !== "127.0.0.1" && remote !== "::1") ||
+        headerCount(req, "host") !== 1 || !config.allowedHosts.includes(req.headers.host || "")) {
+        fail(res, 403, "Forbidden host");
+        return false;
+    }
+    // Native local MCP clients do not need browser origins, CORS or proxy headers.
+    if (req.headers.origin !== undefined || Object.keys(req.headers).some(h => h === "forwarded" || h.startsWith("x-forwarded-"))) {
+        fail(res, 403, "Browser origins and forwarded requests are unsupported");
+        return false;
+    }
+    const auth = req.headers.authorization;
+    const match = typeof auth === "string" ? /^Bearer ([A-Za-z0-9_-]{32,256})$/i.exec(auth) : null;
+    if (headerCount(req, "authorization") !== 1 || !match || !timingSafeEqual(createHash("sha256").update(match[1]).digest(), config.tokenDigest)) {
+        fail(res, 401, "Unauthorized");
+        return false;
+    }
+    return true;
+}
+/** Bounded body ingestion; callers must authenticate before invoking this. */
+export function readJsonBody(req, maxBytes = MAX_BODY_BYTES, timeoutMs = BODY_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        const cleanup = () => {
+            clearTimeout(timer);
+            req.off("data", data);
+            req.off("end", end);
+            req.off("aborted", aborted);
+            req.off("error", error);
+        };
+        const stop = (reason) => { cleanup(); req.pause(); reject(reason); };
+        const timer = setTimeout(() => stop(new HttpFailure(408, "Request body timed out")), timeoutMs);
+        const data = (chunk) => {
+            size += chunk.length;
+            if (size > maxBytes) {
+                stop(new HttpFailure(413, "Request body too large"));
+                return;
+            }
+            chunks.push(chunk);
+        };
+        const end = () => {
+            cleanup();
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+            }
+            catch {
+                reject(new HttpFailure(400, "Invalid JSON"));
+            }
+        };
+        const aborted = () => stop(new HttpFailure(400, "Request aborted"));
+        const error = () => stop(new HttpFailure(400, "Request failed"));
+        req.on("data", data);
+        req.once("end", end);
+        req.once("aborted", aborted);
+        req.once("error", error);
+    });
+}
+export function createPrivateHttpServer(config, handle) {
+    let active = 0;
+    const server = createServer({ maxHeaderSize: 8192 }, (req, res) => {
+        void (async () => {
+            if (!authorize(req, res, config))
+                return;
+            const isMcp = req.url === "/mcp";
+            const isInfo = req.url === "/health" || req.url === "/.well-known/mcp/server-card.json";
+            if (!isMcp && !isInfo) {
+                fail(res, 404, "Not found");
+                return;
+            }
+            const method = isMcp ? "POST" : "GET";
+            if (req.method !== method) {
+                res.setHeader("Allow", method);
+                fail(res, 405, "Method not allowed");
+                return;
+            }
+            if (isMcp && (req.headers["content-type"]?.split(";")[0].trim().toLowerCase() !== "application/json" ||
+                (req.headers["content-encoding"] !== undefined && req.headers["content-encoding"] !== "identity"))) {
+                fail(res, 415, "Only uncompressed application/json is supported");
+                return;
+            }
+            if (Number(req.headers["content-length"] || 0) > MAX_BODY_BYTES) {
+                fail(res, 413, "Request body too large");
+                return;
+            }
+            // No sessions are issued: a supplied session id must never become an auth bypass.
+            if (req.headers["mcp-session-id"] !== undefined) {
+                fail(res, 400, "HTTP MCP is stateless; session identifiers are unsupported");
+                return;
+            }
+            if (active >= MAX_ACTIVE_REQUESTS) {
+                fail(res, 503, "Too many active requests");
+                return;
+            }
+            active++;
+            let released = false;
+            const release = () => { if (!released) {
+                released = true;
+                active--;
+            } };
+            res.once("close", release);
+            res.once("finish", release);
+            res.setHeader("Cache-Control", "no-store");
+            const body = isMcp ? await readJsonBody(req) : undefined;
+            if (!res.destroyed)
+                await handle(req, res, body);
+        })().catch(error => {
+            if (!res.destroyed)
+                fail(res, error instanceof HttpFailure ? error.status : 500, error instanceof HttpFailure ? error.message : "Internal server error");
+        });
+    });
+    server.headersTimeout = 10_000;
+    server.requestTimeout = 15_000;
+    server.keepAliveTimeout = 5_000;
+    server.maxRequestsPerSocket = 100;
+    return server;
+}

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z } from "zod";
 import { VERSION } from "./version.js";
-import { createServer } from "node:http";
+import { createPrivateHttpServer, readHttpConfig } from "./http-security.js";
 // MCP `initialize` response `instructions` field (ServerOptions.instructions in
 // the SDK) — operational guidance for the calling agent, distinct from the
 // package/marketing description in package.json and glama.json. Left unset
@@ -14,7 +14,6 @@ const SERVER_INSTRUCTIONS = "Real-time Solana on-chain intelligence: KOL wallet
 const BASE_URL = process.env.MADEONSOL_API_URL || "https://madeonsol.com";
 const MADEONSOL_API_KEY = process.env.MADEONSOL_API_KEY; // Native key from madeonsol.com/pricing
 const PRIVATE_KEY = process.env.SVM_PRIVATE_KEY; // x402 micropayments (for AI agents)
-const PORT = parseInt(process.env.PORT || "3100", 10);
 const MODE = process.env.MCP_TRANSPORT || "stdio"; // "stdio" or "http"
 let authMode = "none";
 let paidFetch = fetch;
@@ -1275,12 +1274,11 @@ function registerTools(server) {
     });
 }
 async function main() {
+    const httpConfig = MODE === "http" ? readHttpConfig() : undefined;
     await initAuth();
     if (MODE === "http") {
-        // HTTP transport for hosted environments (Smithery, etc.)
-        const httpServer = createServer();
-        const transports = new Map();
-        httpServer.on("request", async (req, res) => {
+        // Configuration is validated before authentication can initialize a signer.
+        const httpServer = createPrivateHttpServer(httpConfig, async (req, res, body) => {
             // Health check
             if (req.method === "GET" && req.url === "/health") {
                 res.writeHead(200, { "Content-Type": "application/json" });
@@ -1292,7 +1290,7 @@ async function main() {
                 res.writeHead(200, { "Content-Type": "application/json" });
                 res.end(JSON.stringify({
                     name: "madeonsol",
-                    description: "Solana KOL trading intelligence and deployer analytics. Real-time data from 1,000+ KOL wallets, 15,500+ Pump.fun deployers, 25,000+ scored alpha wallets, copy-trade rules, and wallet tracker. Supports MadeOnSol API key (msk_) or x402 micropayments.",
+                    description: "Solana KOL trading intelligence and deployer analytics. Real-time data from 1,000+ KOL wallets, 15,500+ Pump.fun deployers, 25,000+ scored alpha wallets, copy-trade rules, and wallet tracker. Private HTTP access with the operator's MadeOnSol API key (msk_).",
                     version: VERSION,
                     tools: [
                         { name: "madeonsol_kol_feed", description: "Get real-time Solana KOL trades from 1,000+ tracked wallets." },
@@ -1390,49 +1388,30 @@ async function main() {
                 }));
                 return;
             }
-            // MCP endpoint
-            const sessionId = req.headers["mcp-session-id"];
-            {
-                if (req.method === "POST") {
-                    let transport = sessionId ? transports.get(sessionId) : undefined;
-                    if (!transport) {
-                        transport = new StreamableHTTPServerTransport({
-                            sessionIdGenerator: undefined,
-                        });
-                        const server = new McpServer({ name: "madeonsol", version: VERSION }, { instructions: SERVER_INSTRUCTIONS });
-                        registerTools(server);
-                        await server.connect(transport);
-                    }
-                    await transport.handleRequest(req, res);
-                    return;
-                }
-                if (req.method === "GET" && sessionId) {
-                    const transport = transports.get(sessionId);
-                    if (transport) {
-                        await transport.handleRequest(req, res);
-                        return;
-                    }
-                }
-                if (req.method === "DELETE" && sessionId) {
-                    const transport = transports.get(sessionId);
-                    if (transport) {
-                        await transport.handleRequest(req, res);
-                        transports.delete(sessionId);
-                        return;
-                    }
-                }
+            // One server/transport per authenticated stateless POST /mcp.
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                enableJsonResponse: true,
+                enableDnsRebindingProtection: true,
+                allowedHosts: httpConfig.allowedHosts,
+                allowedOrigins: [],
+            });
+            const server = new McpServer({ name: "madeonsol", version: VERSION }, { instructions: SERVER_INSTRUCTIONS });
+            res.once("close", () => { void server.close().catch(() => { }); });
+            registerTools(server);
+            await server.connect(transport);
+            if (res.destroyed) {
+                await server.close();
+                return;
             }
-            res.writeHead(404);
-            res.end("Not found");
+            await transport.handleRequest(req, res, body);
         });
-        // Bind to 127.0.0.1 only — defense in depth. UFW already blocks the port
-        // externally, but binding to all interfaces would expose the server to any
-        // misconfigured firewall rule. Override with HOST=0.0.0.0 if you ever need
-        // to expose it directly (e.g. for hosted environments behind a separate
-        // reverse proxy).
-        const HOST = process.env.HOST || "127.0.0.1";
-        httpServer.listen(PORT, HOST, () => {
-            console.error(`[madeonsol-mcp] HTTP server listening on ${HOST}:${PORT}`);
+        httpServer.on("error", () => {
+            console.error("[madeonsol-mcp] HTTP listener failed");
+            process.exitCode = 1;
+        });
+        httpServer.listen(httpConfig.port, httpConfig.host, () => {
+            console.error(`[madeonsol-mcp] HTTP server listening on ${httpConfig.host}:${httpConfig.port}/mcp (private operator only)`);
         });
     }
     else {
@@ -1446,5 +1425,8 @@ async function main() {
 // Only auto-run when executed as a program (CLI / spawned process), not when
 // the module is imported by a test for its exported pure helpers.
 if (process.env.MADEONSOL_MCP_NO_AUTORUN !== "1") {
-    main().catch(console.error);
+    main().catch(error => {
+        console.error(error instanceof Error ? error.message : "MCP startup failed");
+        process.exitCode = 1;
+    });
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.27.1";
+export declare const VERSION = "2.0.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 // AUTO-GENERATED by ../gen-version.mjs (npm prebuild) from package.json. Do not edit.
-export const VERSION = "1.27.1";
+export const VERSION = "2.0.0";