mcp-server-kubernetes 2.6.0 → 2.8.0

package/dist/tools/kubectl-scale.js

@@ -1,6 +1,7 @@
 import { execFileSync } from "child_process";
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 import { getSpawnMaxBuffer } from "../config/max-buffer.js";
+import { contextParameter, namespaceParameter } from "../models/common-parameters.js";
 export const kubectlScaleSchema = {
     name: "kubectl_scale",
     description: "Scale a Kubernetes deployment",
@@ -11,11 +12,7 @@ export const kubectlScaleSchema = {
                 type: "string",
                 description: "Name of the deployment to scale",
             },
-            namespace: {
-                type: "string",
-                description: "Namespace of the deployment",
-                default: "default",
-            },
+            namespace: namespaceParameter,
             replicas: {
                 type: "number",
                 description: "Number of replicas to scale to",
@@ -25,6 +22,7 @@ export const kubectlScaleSchema = {
                 description: "Resource type to scale (deployment, replicaset, statefulset)",
                 default: "deployment",
             },
+            context: contextParameter,
         },
         required: ["name", "replicas"],
     },
@@ -33,6 +31,7 @@ export async function kubectlScale(k8sManager, input) {
     try {
         const namespace = input.namespace || "default";
         const resourceType = input.resourceType || "deployment";
+        const context = input.context || "";
         const command = "kubectl";
         const args = [
             "scale",
@@ -41,6 +40,10 @@ export async function kubectlScale(k8sManager, input) {
             `--replicas=${input.replicas}`,
             `--namespace=${namespace}`,
         ];
+        // Add context if provided
+        if (context) {
+            args.push("--context", context);
+        }
         // Execute the command
         try {
             const result = execFileSync(command, args, {

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.8.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",