mcp-server-kubernetes 3.9.3 → 4.0.1

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

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

package/dist/config/server-config.js

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

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

@@ -76,3 +76,26 @@ export declare function kubectlGet(k8sManager: KubernetesManager, input: {
     }[];
     isError: boolean;
 }>;
+/**
+ * Determine whether a (already lower-cased) resourceType string references
+ * Kubernetes Secrets in any of the syntaxes kubectl accepts. This backs the
+ * masking decision, so it must recognize every way a caller could name a
+ * Secret without tripping the naive "=== 'secret'" check:
+ *   - plain:            "secret", "secrets"
+ *   - resource/name:    "secret/my-secret"
+ *   - group-qualified:  "secrets.v1.", "secret.example.com/my-secret"
+ *   - comma-separated:  "secret,configmap"
+ *
+ * @param {string} resourceType - The lower-cased resourceType argument.
+ * @returns {boolean} True if any referenced resource is a Secret.
+ */
+export declare function resourceReferencesSecret(resourceType: string): boolean;
+/**
+ * Masks sensitive data in Kubernetes secrets by parsing the raw output and replacing
+ * all leaf values in the "data" section with a placeholder value ("***").
+ *
+ * @param {string} output - The raw output from a `kubectl` command, containing secrets data.
+ * @param {string} format - The format of the output, either "json" or "yaml".
+ * @returns {string} - The masked output in the same format as the input.
+ */
+export declare function maskSecretsData(output: string, format: string): string;

package/dist/tools/kubectl-get.js

@@ -126,9 +126,13 @@ export async function kubectlGet(k8sManager, input) {
                 maxBuffer: getSpawnMaxBuffer(),
                 env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
             });
-            // Apply secrets masking if enabled and dealing with secrets
+            // Apply secrets masking if enabled and dealing with secrets.
+            // resourceReferencesSecret normalizes combined forms like
+            // "secret/my-secret", group-qualified "secrets.v1./my-secret", and
+            // comma-separated lists ("secret,configmap") so the masking decision
+            // cannot be bypassed by addressing a Secret through an alternate syntax.
             const shouldMaskSecrets = process.env.MASK_SECRETS !== "false" &&
-                (resourceType === "secrets" || resourceType === "secret");
+                resourceReferencesSecret(resourceType);
             let processedResult = result;
             if (shouldMaskSecrets) {
                 processedResult = maskSecretsData(result, output);
@@ -356,10 +360,54 @@ function isNonNamespacedResource(resourceType) {
     return nonNamespacedResources.includes(resourceType.toLowerCase());
 }
 /**
- * Recursively traverses an object and masks values in 'data' sections of Kubernetes secrets.
+ * Determine whether a (already lower-cased) resourceType string references
+ * Kubernetes Secrets in any of the syntaxes kubectl accepts. This backs the
+ * masking decision, so it must recognize every way a caller could name a
+ * Secret without tripping the naive "=== 'secret'" check:
+ *   - plain:            "secret", "secrets"
+ *   - resource/name:    "secret/my-secret"
+ *   - group-qualified:  "secrets.v1.", "secret.example.com/my-secret"
+ *   - comma-separated:  "secret,configmap"
+ *
+ * @param {string} resourceType - The lower-cased resourceType argument.
+ * @returns {boolean} True if any referenced resource is a Secret.
+ */
+export function resourceReferencesSecret(resourceType) {
+    return resourceType
+        .split(",")
+        .map((part) => {
+        // Drop the "/name" portion of a resource/name reference, then the
+        // ".group"/".version" suffix of a group-qualified reference.
+        const resource = part.trim().split("/")[0].split(".")[0];
+        return resource.toLowerCase();
+    })
+        .some((resource) => resource === "secret" || resource === "secrets");
+}
+// Mask the leaf values of a single Secret object's `data` (and write-only
+// `stringData`) fields, leaving metadata and every other field intact.
+function maskSecretObject(secret) {
+    const result = {};
+    for (const key in secret) {
+        if ((key === "data" || key === "stringData") &&
+            typeof secret[key] === "object" &&
+            secret[key] !== null) {
+            result[key] = maskAllLeafValues(secret[key]);
+        }
+        else {
+            result[key] = maskDataValues(secret[key]);
+        }
+    }
+    return result;
+}
+/**
+ * Recursively traverses a parsed kubectl response and masks the `data` values
+ * of Kubernetes Secrets only. Masking is scoped by object kind rather than by
+ * the presence of a "data" key, so that Secret values are always masked (even
+ * inside a mixed `List` returned by e.g. `kubectl get secret,configmap`) while
+ * non-Secret resources such as ConfigMaps keep their data.
  *
  * @param {any} obj - The object to traverse. Can be an array, object, or primitive value.
- * @returns {any} A new object with masked values in 'data' sections.
+ * @returns {any} A new object with masked values in Secret 'data' sections.
  */
 function maskDataValues(obj) {
     if (obj == null) {
@@ -369,15 +417,24 @@ function maskDataValues(obj) {
         return obj.map((item) => maskDataValues(item));
     }
     if (typeof obj === "object") {
+        const kind = typeof obj.kind === "string" ? obj.kind.toLowerCase() : undefined;
+        // A single Secret object.
+        if (kind === "secret") {
+            return maskSecretObject(obj);
+        }
+        // A SecretList: every item is a Secret, even when kubectl omits the
+        // per-item `kind` field in list output, so mask them unconditionally.
+        if (kind === "secretlist" && Array.isArray(obj.items)) {
+            return {
+                ...obj,
+                items: obj.items.map((item) => maskSecretObject(item)),
+            };
+        }
+        // Any other object (including a heterogeneous "List"): recurse so nested
+        // Secret objects are still masked without touching non-Secret data.
         const result = {};
         for (const key in obj) {
-            if (key === "data" && typeof obj[key] === "object" && obj[key] !== null) {
-                // This is a data section - mask all leaf values within it
-                result[key] = maskAllLeafValues(obj[key]);
-            }
-            else {
-                result[key] = maskDataValues(obj[key]);
-            }
+            result[key] = maskDataValues(obj[key]);
         }
         return result;
     }
@@ -415,7 +472,7 @@ function maskAllLeafValues(obj) {
  * @param {string} format - The format of the output, either "json" or "yaml".
  * @returns {string} - The masked output in the same format as the input.
  */
-function maskSecretsData(output, format) {
+export function maskSecretsData(output, format) {
     try {
         if (format === "json") {
             const parsed = JSON.parse(output);

package/dist/tools/port_forward.js

@@ -1,6 +1,13 @@
 import { spawn } from "child_process";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+import { assertSafeArgv } from "../security/kubectl-flags.js";
 // Use spawn instead of exec because port-forward is a long-running process
 async function executePortForward(args) {
+    // port_forward uses spawn (long-running process) rather than the shared
+    // execFileSyncSafe wrapper, so it must run the argv guard itself. Otherwise
+    // user-supplied values pushed into positional slots (e.g. resourceType) can
+    // smuggle credential/target-redirecting flags such as --server.
+    assertSafeArgv(args);
     return new Promise((resolve, reject) => {
         const process = spawn("kubectl", args);
         let output = "";
@@ -92,6 +99,10 @@ export async function startPortForward(k8sManager, input) {
         };
     }
     catch (error) {
+        // Preserve McpError (e.g. the argv safety guard's InvalidParams rejection)
+        // so the client sees the real reason instead of a generic InternalError.
+        if (error instanceof McpError)
+            throw error;
         throw new Error(`Failed to execute port-forward: ${error.message}`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "3.9.3",
+  "version": "4.0.1",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",