mcp-server-kubernetes 2.6.0 → 2.7.0

package/dist/index.js

@@ -24,6 +24,7 @@ import { kubectlPatch, kubectlPatchSchema } from "./tools/kubectl-patch.js";
 import { kubectlRollout, kubectlRolloutSchema, } from "./tools/kubectl-rollout.js";
 import { registerPromptHandlers } from "./prompts/index.js";
 import { ping, pingSchema } from "./tools/ping.js";
+import { startStreamableHTTPServer } from "./utils/streamable-http.js";
 // Check environment variables for tool filtering
 const allowOnlyReadonlyTools = process.env.ALLOW_ONLY_READONLY_TOOLS === "true";
 const allowedToolsEnv = process.env.ALLOWED_TOOLS;
@@ -217,6 +218,10 @@ if (process.env.ENABLE_UNSAFE_SSE_TRANSPORT) {
     startSSEServer(server);
     console.log(`SSE server started`);
 }
+else if (process.env.ENABLE_UNSAFE_STREAMABLE_HTTP_TRANSPORT) {
+    startStreamableHTTPServer(server);
+    console.log(`Streamable HTTP server started`);
+}
 else {
     const transport = new StdioServerTransport();
     console.error(`Starting Kubernetes MCP server v${serverConfig.version}, handling commands...`);

package/dist/utils/streamable-http.d.ts

@@ -0,0 +1,3 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import http from "http";
+export declare function startStreamableHTTPServer(server: Server): http.Server;

package/dist/utils/streamable-http.js

@@ -0,0 +1,79 @@
+import express from "express";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+export function startStreamableHTTPServer(server) {
+    const app = express();
+    app.use(express.json());
+    app.post("/mcp", async (req, res) => {
+        // In stateless mode, create a new instance of transport and server for each request
+        // to ensure complete isolation. A single instance would cause request ID collisions
+        // when multiple clients connect concurrently.
+        try {
+            // DNS rebinding protection is disabled by default for backwards compatibility. If you are running this server
+            // locally, make sure to set DNS_REBINDING_PROTECTION=true
+            const enableDnsRebindingProtection = process.env.DNS_REBINDING_PROTECTION === "true";
+            const allowedHosts = process.env.DNS_REBINDING_ALLOWED_HOST
+                ? [process.env.DNS_REBINDING_ALLOWED_HOST]
+                : ["127.0.0.1"];
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                enableDnsRebindingProtection,
+                allowedHosts,
+            });
+            res.on("close", () => {
+                transport.close();
+                server.close();
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            console.error("Error handling MCP request:", error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error",
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    // SSE notifications not supported in stateless mode
+    app.get("/mcp", async (req, res) => {
+        console.log("Received GET MCP request");
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed.",
+            },
+            id: null,
+        }));
+    });
+    // Session termination not needed in stateless mode
+    app.delete("/mcp", async (req, res) => {
+        console.log("Received DELETE MCP request");
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed.",
+            },
+            id: null,
+        }));
+    });
+    let port = 3000;
+    try {
+        port = parseInt(process.env.PORT || "3000", 10);
+    }
+    catch (e) {
+        console.error("Invalid PORT environment variable, using default port 3000.");
+    }
+    const host = process.env.HOST || "localhost";
+    const httpServer = app.listen(port, host, () => {
+        console.log(`mcp-kubernetes-server is listening on port ${port}\nUse the following url to connect to the server:\nhttp://${host}:${port}/mcp`);
+    });
+    return httpServer;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@kubernetes/client-node": "1.3.0",
-    "@modelcontextprotocol/sdk": "1.7.0",
+    "@modelcontextprotocol/sdk": "1.17.0",
     "express": "4.21.2",
     "js-yaml": "4.1.0",
     "yaml": "2.7.0",