mcp-server-kubernetes 4.0.1 → 4.0.3

package/README.md

@@ -10,6 +10,7 @@
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/Flux159/mcp-server-kubernetes/pulls)
 [![Last Commit](https://img.shields.io/github/last-commit/Flux159/mcp-server-kubernetes)](https://github.com/Flux159/mcp-server-kubernetes/commits/main)
 [![Trust Score](https://archestra.ai/mcp-catalog/api/badge/quality/Flux159/mcp-server-kubernetes)](https://archestra.ai/mcp-catalog/flux159__mcp-server-kubernetes)
+[![HVTrust](https://hvtracker.net/badge/kubernetes-mcp-server.svg)](https://hvtracker.net/agents/kubernetes-mcp-server/)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/Flux159/mcp-server-kubernetes)
 
 <p align="center">

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

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

package/dist/config/server-config.js

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

package/dist/index.d.ts

@@ -616,7 +616,7 @@ declare const allTools: ({
             };
             readonly filename: {
                 readonly type: "string";
-                readonly description: "Path to a YAML file to create resources from";
+                readonly description: "Path to a YAML file to create resources from. The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead.";
             };
             readonly resourceType: {
                 readonly type: "string";
@@ -643,7 +643,26 @@ declare const allTools: ({
                 readonly items: {
                     readonly type: "string";
                 };
-                readonly description: "Path to file for creating configmap (e.g. [\"key1=/path/to/file1\", \"key2=/path/to/file2\"])";
+                readonly description: "Path to file for creating configmap/secret (e.g. [\"key1=/path/to/file1\", \"key2=/path/to/file2\"]). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use \"fromFileContent\" to pass file contents directly instead.";
+            };
+            readonly fromFileContent: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly key: {
+                            readonly type: "string";
+                            readonly description: "Key to store the content under in the configmap/secret";
+                        };
+                        readonly content: {
+                            readonly type: "string";
+                            readonly description: "The file content to store";
+                        };
+                    };
+                    readonly required: readonly ["key", "content"];
+                    readonly additionalProperties: false;
+                };
+                readonly description: "Inline file contents for creating a configmap/secret, provided by the client instead of a server-side path (e.g. [{\"key\": \"app.conf\", \"content\": \"...\"}]). Safe on all transports; use this instead of \"fromFile\" on remote (SSE/Streamable HTTP) servers.";
             };
             readonly secretType: {
                 readonly type: "string";

package/dist/security/transport.d.ts

@@ -0,0 +1 @@
+export declare function isRemoteTransport(): boolean;

package/dist/security/transport.js

@@ -0,0 +1,17 @@
+// Transport-mode detection for security decisions.
+//
+// The server selects its transport at startup based on these env vars (see
+// src/index.ts): if either is set the server listens over HTTP (SSE or
+// Streamable HTTP) and serves remote clients; otherwise it uses stdio and is
+// driven by a local process that already runs as the operator.
+//
+// Some tool inputs are only safe under the stdio trust model. A server-side
+// filesystem path (e.g. `--from-file` / `-f`) is read on the machine running
+// the server: over stdio that machine is the operator's own, but over HTTP it
+// is the server host, so any client that can reach the endpoint could read
+// arbitrary files (kubeconfig, service-account token, /proc/self/environ).
+// Guards use this helper to reject path-based reads on remote transports.
+export function isRemoteTransport() {
+    return Boolean(process.env.ENABLE_UNSAFE_SSE_TRANSPORT ||
+        process.env.ENABLE_UNSAFE_STREAMABLE_HTTP_TRANSPORT);
+}

package/dist/tools/kubectl-create.d.ts

@@ -27,7 +27,7 @@ export declare const kubectlCreateSchema: {
             };
             readonly filename: {
                 readonly type: "string";
-                readonly description: "Path to a YAML file to create resources from";
+                readonly description: "Path to a YAML file to create resources from. The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead.";
             };
             readonly resourceType: {
                 readonly type: "string";
@@ -54,7 +54,26 @@ export declare const kubectlCreateSchema: {
                 readonly items: {
                     readonly type: "string";
                 };
-                readonly description: "Path to file for creating configmap (e.g. [\"key1=/path/to/file1\", \"key2=/path/to/file2\"])";
+                readonly description: "Path to file for creating configmap/secret (e.g. [\"key1=/path/to/file1\", \"key2=/path/to/file2\"]). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use \"fromFileContent\" to pass file contents directly instead.";
+            };
+            readonly fromFileContent: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly key: {
+                            readonly type: "string";
+                            readonly description: "Key to store the content under in the configmap/secret";
+                        };
+                        readonly content: {
+                            readonly type: "string";
+                            readonly description: "The file content to store";
+                        };
+                    };
+                    readonly required: readonly ["key", "content"];
+                    readonly additionalProperties: false;
+                };
+                readonly description: "Inline file contents for creating a configmap/secret, provided by the client instead of a server-side path (e.g. [{\"key\": \"app.conf\", \"content\": \"...\"}]). Safe on all transports; use this instead of \"fromFile\" on remote (SSE/Streamable HTTP) servers.";
             };
             readonly secretType: {
                 readonly type: "string";
@@ -136,6 +155,10 @@ export declare function kubectlCreate(k8sManager: KubernetesManager, input: {
     namespace?: string;
     fromLiteral?: string[];
     fromFile?: string[];
+    fromFileContent?: {
+        key: string;
+        content: string;
+    }[];
     secretType?: "generic" | "docker-registry" | "tls";
     serviceType?: "clusterip" | "nodeport" | "loadbalancer" | "externalname";
     tcpPort?: string[];

package/dist/tools/kubectl-create.js

@@ -5,6 +5,7 @@ import * as path from "path";
 import * as os from "os";
 import { getSpawnMaxBuffer } from "../config/max-buffer.js";
 import { contextParameter, namespaceParameter, dryRunParameter } from "../models/common-parameters.js";
+import { isRemoteTransport } from "../security/transport.js";
 export const kubectlCreateSchema = {
     name: "kubectl_create",
     description: "Create Kubernetes resources using various methods (from file or using subcommands)",
@@ -42,7 +43,7 @@ export const kubectlCreateSchema = {
             },
             filename: {
                 type: "string",
-                description: "Path to a YAML file to create resources from",
+                description: "Path to a YAML file to create resources from. The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead.",
             },
             // Resource type to create (determines which subcommand to use)
             resourceType: {
@@ -64,7 +65,26 @@ export const kubectlCreateSchema = {
             fromFile: {
                 type: "array",
                 items: { type: "string" },
-                description: 'Path to file for creating configmap (e.g. ["key1=/path/to/file1", "key2=/path/to/file2"])',
+                description: 'Path to file for creating configmap/secret (e.g. ["key1=/path/to/file1", "key2=/path/to/file2"]). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use "fromFileContent" to pass file contents directly instead.',
+            },
+            fromFileContent: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        key: {
+                            type: "string",
+                            description: "Key to store the content under in the configmap/secret",
+                        },
+                        content: {
+                            type: "string",
+                            description: "The file content to store",
+                        },
+                    },
+                    required: ["key", "content"],
+                    additionalProperties: false,
+                },
+                description: 'Inline file contents for creating a configmap/secret, provided by the client instead of a server-side path (e.g. [{"key": "app.conf", "content": "..."}]). Safe on all transports; use this instead of "fromFile" on remote (SSE/Streamable HTTP) servers.',
             },
             // Namespace specific parameters
             // No special parameters for namespace, just name is needed
@@ -143,6 +163,21 @@ export async function kubectlCreate(k8sManager, input) {
             input.resourceType !== "namespace") {
             throw new McpError(ErrorCode.InvalidRequest, `Name is required when creating a ${input.resourceType}`);
         }
+        // Reject server-side filesystem reads on remote transports. Over SSE /
+        // Streamable HTTP the path resolves on the MCP server host, not the
+        // client, so `filename` (-f) and `fromFile` (--from-file) would let any
+        // client that can reach the endpoint read arbitrary server files
+        // (kubeconfig, service-account token, /proc/self/environ, etc.). See
+        // GHSA-m67f-jxm9-cvx8. Clients on these transports must pass content
+        // inline via `manifest` or `fromFileContent` instead.
+        if (isRemoteTransport()) {
+            if (input.filename) {
+                throw new McpError(ErrorCode.InvalidRequest, "The 'filename' parameter reads a file from the MCP server's filesystem and is disabled on remote (SSE/Streamable HTTP) transports. Pass the file contents via 'manifest' instead.");
+            }
+            if (input.fromFile && input.fromFile.length > 0) {
+                throw new McpError(ErrorCode.InvalidRequest, "The 'fromFile' parameter reads files from the MCP server's filesystem and is disabled on remote (SSE/Streamable HTTP) transports. Pass the file contents via 'fromFileContent' instead.");
+            }
+        }
         // Set up common parameters
         const namespace = input.namespace || "default";
         const dryRun = input.dryRun || false;
@@ -151,15 +186,33 @@ export async function kubectlCreate(k8sManager, input) {
         const context = input.context || "";
         const command = "kubectl";
         const args = ["create"];
-        let tempFile = null;
+        const tempFiles = [];
+        // Write client-provided content to a private temp file and return its
+        // path. The file is tracked for cleanup after kubectl runs.
+        const writeTempFile = (contents, label, ext = "") => {
+            const tmpDir = os.tmpdir();
+            const tempFile = path.join(tmpDir, `create-${label}-${Date.now()}-${tempFiles.length}${ext}`);
+            fs.writeFileSync(tempFile, contents, { mode: 0o600 });
+            tempFiles.push(tempFile);
+            return tempFile;
+        };
+        // Emit `--from-file=<key>=<tempfile>` args for inline content supplied by
+        // the client. Each entry's content is written to a server-side temp file
+        // (never a client-controlled path), so this is safe on all transports.
+        const pushFromFileContent = (entries) => {
+            entries.forEach((entry) => {
+                if (!entry.key) {
+                    throw new McpError(ErrorCode.InvalidRequest, "Each fromFileContent entry requires a non-empty 'key'");
+                }
+                const tempFile = writeTempFile(entry.content ?? "", "fromfile");
+                args.push(`--from-file=${entry.key}=${tempFile}`);
+            });
+        };
         // Process manifest content if provided (file-based creation)
         if (input.manifest || input.filename) {
             if (input.manifest) {
                 // Create temporary file for the manifest
-                const tmpDir = os.tmpdir();
-                tempFile = path.join(tmpDir, `create-manifest-${Date.now()}.yaml`);
-                fs.writeFileSync(tempFile, input.manifest);
-                args.push("-f", tempFile);
+                args.push("-f", writeTempFile(input.manifest, "manifest", ".yaml"));
             }
             else if (input.filename) {
                 args.push("-f", input.filename);
@@ -179,12 +232,17 @@ export async function kubectlCreate(k8sManager, input) {
                             args.push(`--from-literal=${literal}`);
                         });
                     }
-                    // Add --from-file arguments
+                    // Add --from-file arguments (server-side paths; blocked on remote
+                    // transports by the guard above)
                     if (input.fromFile && input.fromFile.length > 0) {
                         input.fromFile.forEach((file) => {
                             args.push(`--from-file=${file}`);
                         });
                     }
+                    // Add inline file contents (safe on all transports)
+                    if (input.fromFileContent && input.fromFileContent.length > 0) {
+                        pushFromFileContent(input.fromFileContent);
+                    }
                     break;
                 case "secret":
                     if (!input.secretType) {
@@ -197,12 +255,17 @@ export async function kubectlCreate(k8sManager, input) {
                             args.push(`--from-literal=${literal}`);
                         });
                     }
-                    // Add --from-file arguments
+                    // Add --from-file arguments (server-side paths; blocked on remote
+                    // transports by the guard above)
                     if (input.fromFile && input.fromFile.length > 0) {
                         input.fromFile.forEach((file) => {
                             args.push(`--from-file=${file}`);
                         });
                     }
+                    // Add inline file contents (safe on all transports)
+                    if (input.fromFileContent && input.fromFileContent.length > 0) {
+                        pushFromFileContent(input.fromFileContent);
+                    }
                     break;
                 case "service":
                     if (!input.serviceType) {
@@ -292,6 +355,17 @@ export async function kubectlCreate(k8sManager, input) {
         if (context) {
             args.push("--context", context);
         }
+        // Remove any temp files created for inline content.
+        const cleanupTempFiles = () => {
+            tempFiles.forEach((tempFile) => {
+                try {
+                    fs.unlinkSync(tempFile);
+                }
+                catch (err) {
+                    console.warn(`Failed to delete temporary file ${tempFile}: ${err}`);
+                }
+            });
+        };
         // Execute the command
         try {
             const result = execFileSyncSafe(command, args, {
@@ -299,15 +373,8 @@ export async function kubectlCreate(k8sManager, input) {
                 maxBuffer: getSpawnMaxBuffer(),
                 env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
             });
-            // Clean up temp file if created
-            if (tempFile) {
-                try {
-                    fs.unlinkSync(tempFile);
-                }
-                catch (err) {
-                    console.warn(`Failed to delete temporary file ${tempFile}: ${err}`);
-                }
-            }
+            // Clean up temp files if created
+            cleanupTempFiles();
             return {
                 content: [
                     {
@@ -318,15 +385,8 @@ export async function kubectlCreate(k8sManager, input) {
             };
         }
         catch (error) {
-            // Clean up temp file if created, even if command failed
-            if (tempFile) {
-                try {
-                    fs.unlinkSync(tempFile);
-                }
-                catch (err) {
-                    console.warn(`Failed to delete temporary file ${tempFile}: ${err}`);
-                }
-            }
+            // Clean up temp files if created, even if command failed
+            cleanupTempFiles();
             throw new McpError(ErrorCode.InternalError, `Failed to create resource: ${error.message}`);
         }
     }

package/dist/tools/kubectl-get.js

@@ -113,10 +113,10 @@ export async function kubectlGet(k8sManager, input) {
         }
         else if (output === "custom") {
             if (resourceType === "events") {
-                args.push("-o", "'custom-columns=LASTSEEN:.lastTimestamp,TYPE:.type,REASON:.reason,OBJECT:.involvedObject.name,MESSAGE:.message'");
+                args.push("-o", "custom-columns=LASTSEEN:.lastTimestamp,TYPE:.type,REASON:.reason,OBJECT:.involvedObject.name,MESSAGE:.message");
             }
             else {
-                args.push("-o", "'custom-columns=NAME:.metadata.name,NAMESPACE:.metadata.namespace,STATUS:.status.phase,AGE:.metadata.creationTimestamp'");
+                args.push("-o", "custom-columns=NAME:.metadata.name,NAMESPACE:.metadata.namespace,STATUS:.status.phase,AGE:.metadata.creationTimestamp");
             }
         }
         // Execute the command

package/dist/tools/kubectl-logs.js

@@ -63,7 +63,7 @@ export const kubectlLogsSchema = {
 };
 export async function kubectlLogs(k8sManager, input) {
     try {
-        const resourceType = input.resourceType.toLowerCase();
+        const resourceType = (input.resourceType ?? "pod").toLowerCase();
         const name = input.name;
         const namespace = input.namespace || "default";
         const context = input.context || "";
@@ -108,7 +108,7 @@ export async function kubectlLogs(k8sManager, input) {
                     "deployment",
                     name,
                     "-o",
-                    "jsonpath='{.spec.selector.matchLabels}'",
+                    "jsonpath={.spec.selector.matchLabels}",
                 ];
             }
             else if (resourceType === "job") {
@@ -124,7 +124,7 @@ export async function kubectlLogs(k8sManager, input) {
                     "jobs",
                     "--selector=job-name=" + name,
                     "-o",
-                    "jsonpath='{.items[*].metadata.name}'",
+                    "jsonpath={.items[*].metadata.name}",
                 ];
                 try {
                     const jobs = execFileSyncSafe(command, jobsArgs, {
@@ -182,7 +182,7 @@ export async function kubectlLogs(k8sManager, input) {
                         maxBuffer: getSpawnMaxBuffer(),
                         env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
                     }).trim();
-                    const selector = JSON.parse(selectorJson.replace(/'/g, '"'));
+                    const selector = JSON.parse(selectorJson);
                     // Convert to label selector format
                     const labelSelector = Object.entries(selector)
                         .map(([key, value]) => `${key}=${value}`)
@@ -258,7 +258,7 @@ async function getLabelSelectorLogs(labelSelector, namespace, input) {
             "pods",
             `--selector=${labelSelector}`,
             "-o",
-            "jsonpath='{.items[*].metadata.name}'",
+            "jsonpath={.items[*].metadata.name}",
         ];
         const pods = execFileSyncSafe(command, podsArgs, {
             encoding: "utf8",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "4.0.1",
+  "version": "4.0.3",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -57,6 +57,6 @@
     "@types/node": "22.9.3",
     "shx": "0.3.4",
     "typescript": "5.6.2",
-    "vitest": "2.1.9"
+    "vitest": "3.2.6"
   }
 }