mcp-server-kubernetes 4.0.7 → 4.0.9

package/dist/config/server-config.d.ts

@@ -1,6 +1,6 @@
 export declare const serverConfig: {
     readonly name: "kubernetes";
-    readonly version: "4.0.7";
+    readonly version: "4.0.9";
     readonly capabilities: {
         readonly resources: {};
         readonly tools: {};

package/dist/config/server-config.js

@@ -1,6 +1,6 @@
 export const serverConfig = {
     name: "kubernetes",
-    version: "4.0.7",
+    version: "4.0.9",
     capabilities: {
         resources: {},
         tools: {},

package/dist/tools/exec_in_pod.js

@@ -103,6 +103,28 @@ export async function execInPod(k8sManager, input) {
         if (error.killed || error.signal === "SIGTERM") {
             throw new McpError(ErrorCode.InternalError, "Exec operation timed out (possible networking, RBAC, or cluster issue)");
         }
+        // A non-zero exit code from the command inside the pod is a NORMAL outcome of
+        // running commands, not an internal tool error. Throwing here discards stdout
+        // entirely (execFileSync attaches it to the error object), which loses all
+        // partial output — e.g. a diagnostic command that prints 20 useful lines and
+        // then exits 1 previously returned only "command terminated with exit code 1".
+        // Return stdout + stderr + the exit code instead, so callers see everything
+        // the command produced. Genuine spawn/infra failures (kubectl missing, RBAC,
+        // connection refused) have no exit status and still throw below.
+        if (typeof error.status === "number") {
+            const stdout = (error.stdout ?? "").toString();
+            const stderr = (error.stderr ?? "").toString();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Command exited with code ${error.status}\n` +
+                            (stdout ? `--- stdout ---\n${stdout}\n` : "") +
+                            (stderr ? `--- stderr ---\n${stderr}` : ""),
+                    },
+                ],
+            };
+        }
         throw new McpError(ErrorCode.InternalError, `Failed to execute command in pod: ${error.stderr || error.message}`);
     }
 }

package/dist/utils/sse.js

@@ -1,15 +1,65 @@
 import express from "express";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { createAuthMiddleware, isAuthEnabled } from "./auth.js";
+/**
+ * Build the default allowedHosts list for DNS rebinding protection.
+ * Includes localhost variants with and without port.
+ */
+function buildDefaultAllowedHosts(host, port) {
+    // Always allow the bare host and host:port for common localhost addresses
+    const localhostAliases = ["127.0.0.1", "localhost", "::1"];
+    const hosts = [];
+    for (const alias of localhostAliases) {
+        hosts.push(alias);
+        // HTTP Host header uses bracket notation for IPv6: [::1]:3000
+        if (alias.includes(":")) {
+            hosts.push(`[${alias}]`);
+            hosts.push(`[${alias}]:${port}`);
+        }
+        else {
+            hosts.push(`${alias}:${port}`);
+        }
+    }
+    // Also add the configured host if it's not already covered
+    if (!localhostAliases.includes(host)) {
+        hosts.push(host);
+        if (host.includes(":") && !host.startsWith("[")) {
+            hosts.push(`[${host}]`);
+            hosts.push(`[${host}]:${port}`);
+        }
+        else {
+            hosts.push(`${host}:${port}`);
+        }
+    }
+    return hosts;
+}
 export function startSSEServer(server) {
     const app = express();
     // Create auth middleware - when MCP_AUTH_TOKEN is set, requires X-MCP-AUTH header
     const authMiddleware = createAuthMiddleware();
+    // DNS rebinding protection is enabled by default. Set DNS_REBINDING_PROTECTION=false to disable.
+    const enableDnsRebindingProtection = process.env.DNS_REBINDING_PROTECTION !== "false";
+    const host = process.env.HOST || "localhost";
+    const parsed = parseInt(process.env.PORT || "3000", 10);
+    const port = Number.isNaN(parsed) ? 3000 : parsed;
+    const allowedHosts = process.env.DNS_REBINDING_ALLOWED_HOST
+        ? [process.env.DNS_REBINDING_ALLOWED_HOST]
+        : buildDefaultAllowedHosts(host, port);
+    // Warn when binding to all interfaces with DNS rebinding protection disabled
+    if (!enableDnsRebindingProtection && (host === "0.0.0.0" || host === "::")) {
+        console.warn("WARNING: DNS rebinding protection is disabled while HOST is set to " +
+            `'${host}'. This exposes the MCP server to DNS rebinding attacks ` +
+            "from any browser on the network. Set DNS_REBINDING_PROTECTION=true " +
+            "(the default) or restrict HOST to 'localhost' / '127.0.0.1'.");
+    }
     // Currently just copying from docs & allowing for multiple transport connections: https://modelcontextprotocol.io/docs/concepts/transports#server-sent-events-sse
     // Note: When MCP_AUTH_TOKEN is set, requests require X-MCP-AUTH header for authentication
     let transports = [];
     app.get("/sse", authMiddleware, async (req, res) => {
-        const transport = new SSEServerTransport("/messages", res);
+        const transport = new SSEServerTransport("/messages", res, {
+            enableDnsRebindingProtection,
+            allowedHosts,
+        });
         transports.push(transport);
         await server.connect(transport);
     });
@@ -45,14 +95,6 @@ export function startSSEServer(server) {
             });
         }
     });
-    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";
     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}/sse`);
         if (isAuthEnabled()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "4.0.7",
+  "version": "4.0.9",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -46,7 +46,7 @@
     "@opentelemetry/sdk-node": "0.219.0",
     "@opentelemetry/semantic-conventions": "1.40.0",
     "express": "4.21.2",
-    "js-yaml": "4.1.1",
+    "js-yaml": "4.3.0",
     "yaml": "2.8.3",
     "zod": "3.25.76"
   },