mcp-server-kubernetes 2.4.9 → 2.5.0

package/dist/tools/kubectl-create.js

@@ -1,8 +1,9 @@
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { getSpawnMaxBuffer } from "../config/max-buffer.js";
 export const kubectlCreateSchema = {
     name: "kubectl_create",
     description: "Create Kubernetes resources using various methods (from file or using subcommands)",
@@ -13,53 +14,64 @@ export const kubectlCreateSchema = {
             dryRun: {
                 type: "boolean",
                 description: "If true, only validate the resource, don't actually create it",
-                default: false
+                default: false,
             },
             output: {
                 type: "string",
-                enum: ["json", "yaml", "name", "go-template", "go-template-file", "template", "templatefile", "jsonpath", "jsonpath-as-json", "jsonpath-file"],
+                enum: [
+                    "json",
+                    "yaml",
+                    "name",
+                    "go-template",
+                    "go-template-file",
+                    "template",
+                    "templatefile",
+                    "jsonpath",
+                    "jsonpath-as-json",
+                    "jsonpath-file",
+                ],
                 description: "Output format. One of: json|yaml|name|go-template|go-template-file|template|templatefile|jsonpath|jsonpath-as-json|jsonpath-file",
-                default: "yaml"
+                default: "yaml",
             },
             validate: {
                 type: "boolean",
                 description: "If true, validate resource schema against server schema",
-                default: true
+                default: true,
             },
             // Create from file method
             manifest: {
                 type: "string",
-                description: "YAML manifest to create resources from"
+                description: "YAML manifest to create resources from",
             },
             filename: {
                 type: "string",
-                description: "Path to a YAML file to create resources from"
+                description: "Path to a YAML file to create resources from",
             },
             // Resource type to create (determines which subcommand to use)
             resourceType: {
                 type: "string",
-                description: "Type of resource to create (namespace, configmap, deployment, service, etc.)"
+                description: "Type of resource to create (namespace, configmap, deployment, service, etc.)",
             },
             // Common parameters for most resource types
             name: {
                 type: "string",
-                description: "Name of the resource to create"
+                description: "Name of the resource to create",
             },
             namespace: {
                 type: "string",
                 description: "Namespace to create the resource in",
-                default: "default"
+                default: "default",
             },
             // ConfigMap specific parameters
             fromLiteral: {
                 type: "array",
                 items: { type: "string" },
-                description: "Key-value pair for creating configmap (e.g. [\"key1=value1\", \"key2=value2\"])"
+                description: 'Key-value pair for creating configmap (e.g. ["key1=value1", "key2=value2"])',
             },
             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 (e.g. ["key1=/path/to/file1", "key2=/path/to/file2"])',
             },
             // Namespace specific parameters
             // No special parameters for namespace, just name is needed
@@ -67,60 +79,60 @@ export const kubectlCreateSchema = {
             secretType: {
                 type: "string",
                 enum: ["generic", "docker-registry", "tls"],
-                description: "Type of secret to create (generic, docker-registry, tls)"
+                description: "Type of secret to create (generic, docker-registry, tls)",
             },
             // Service specific parameters
             serviceType: {
                 type: "string",
                 enum: ["clusterip", "nodeport", "loadbalancer", "externalname"],
-                description: "Type of service to create (clusterip, nodeport, loadbalancer, externalname)"
+                description: "Type of service to create (clusterip, nodeport, loadbalancer, externalname)",
             },
             tcpPort: {
                 type: "array",
                 items: { type: "string" },
-                description: "Port pairs for tcp service (e.g. [\"80:8080\", \"443:8443\"])"
+                description: 'Port pairs for tcp service (e.g. ["80:8080", "443:8443"])',
             },
             // Deployment specific parameters
             image: {
                 type: "string",
-                description: "Image to use for the containers in the deployment"
+                description: "Image to use for the containers in the deployment",
             },
             replicas: {
                 type: "number",
                 description: "Number of replicas to create for the deployment",
-                default: 1
+                default: 1,
             },
             port: {
                 type: "number",
-                description: "Port that the container exposes"
+                description: "Port that the container exposes",
             },
             // CronJob specific parameters
             schedule: {
                 type: "string",
-                description: "Cron schedule expression for the CronJob (e.g. \"*/5 * * * *\")"
+                description: 'Cron schedule expression for the CronJob (e.g. "*/5 * * * *")',
             },
             suspend: {
                 type: "boolean",
                 description: "Whether to suspend the CronJob",
-                default: false
+                default: false,
             },
             // Job specific parameters
             command: {
                 type: "array",
                 items: { type: "string" },
-                description: "Command to run in the container"
+                description: "Command to run in the container",
             },
             // Additional common parameters
             labels: {
                 type: "array",
                 items: { type: "string" },
-                description: "Labels to apply to the resource (e.g. [\"key1=value1\", \"key2=value2\"])"
+                description: 'Labels to apply to the resource (e.g. ["key1=value1", "key2=value2"])',
             },
             annotations: {
                 type: "array",
                 items: { type: "string" },
-                description: "Annotations to apply to the resource (e.g. [\"key1=value1\", \"key2=value2\"])"
-            }
+                description: 'Annotations to apply to the resource (e.g. ["key1=value1", "key2=value2"])',
+            },
         },
         required: [],
     },
@@ -132,7 +144,9 @@ export async function kubectlCreate(k8sManager, input) {
             throw new McpError(ErrorCode.InvalidRequest, "Either manifest, filename, or resourceType must be provided");
         }
         // If resourceType is provided, check if name is provided for most resource types
-        if (input.resourceType && !input.name && input.resourceType !== "namespace") {
+        if (input.resourceType &&
+            !input.name &&
+            input.resourceType !== "namespace") {
             throw new McpError(ErrorCode.InvalidRequest, `Name is required when creating a ${input.resourceType}`);
         }
         // Set up common parameters
@@ -140,7 +154,8 @@ export async function kubectlCreate(k8sManager, input) {
         const dryRun = input.dryRun || false;
         const validate = input.validate ?? true;
         const output = input.output || "yaml";
-        let command = "kubectl create";
+        const command = "kubectl";
+        const args = ["create"];
         let tempFile = null;
         // Process manifest content if provided (file-based creation)
         if (input.manifest || input.filename) {
@@ -149,30 +164,30 @@ export async function kubectlCreate(k8sManager, input) {
                 const tmpDir = os.tmpdir();
                 tempFile = path.join(tmpDir, `create-manifest-${Date.now()}.yaml`);
                 fs.writeFileSync(tempFile, input.manifest);
-                command += ` -f ${tempFile}`;
+                args.push("-f", tempFile);
             }
             else if (input.filename) {
-                command += ` -f ${input.filename}`;
+                args.push("-f", input.filename);
             }
         }
         else {
             // Process subcommand-based creation
             switch (input.resourceType?.toLowerCase()) {
                 case "namespace":
-                    command += ` namespace ${input.name}`;
+                    args.push("namespace", input.name);
                     break;
                 case "configmap":
-                    command += ` configmap ${input.name}`;
+                    args.push("configmap", input.name);
                     // Add --from-literal arguments
                     if (input.fromLiteral && input.fromLiteral.length > 0) {
-                        input.fromLiteral.forEach(literal => {
-                            command += ` --from-literal=${literal}`;
+                        input.fromLiteral.forEach((literal) => {
+                            args.push(`--from-literal=${literal}`);
                         });
                     }
                     // Add --from-file arguments
                     if (input.fromFile && input.fromFile.length > 0) {
-                        input.fromFile.forEach(file => {
-                            command += ` --from-file=${file}`;
+                        input.fromFile.forEach((file) => {
+                            args.push(`--from-file=${file}`);
                         });
                     }
                     break;
@@ -180,17 +195,17 @@ export async function kubectlCreate(k8sManager, input) {
                     if (!input.secretType) {
                         throw new McpError(ErrorCode.InvalidRequest, "secretType is required when creating a secret");
                     }
-                    command += ` secret ${input.secretType} ${input.name}`;
+                    args.push("secret", input.secretType, input.name);
                     // Add --from-literal arguments
                     if (input.fromLiteral && input.fromLiteral.length > 0) {
-                        input.fromLiteral.forEach(literal => {
-                            command += ` --from-literal=${literal}`;
+                        input.fromLiteral.forEach((literal) => {
+                            args.push(`--from-literal=${literal}`);
                         });
                     }
                     // Add --from-file arguments
                     if (input.fromFile && input.fromFile.length > 0) {
-                        input.fromFile.forEach(file => {
-                            command += ` --from-file=${file}`;
+                        input.fromFile.forEach((file) => {
+                            args.push(`--from-file=${file}`);
                         });
                     }
                     break;
@@ -199,11 +214,11 @@ export async function kubectlCreate(k8sManager, input) {
                         // Default to clusterip if not specified
                         input.serviceType = "clusterip";
                     }
-                    command += ` service ${input.serviceType} ${input.name}`;
+                    args.push("service", input.serviceType, input.name);
                     // Add --tcp arguments for ports
                     if (input.tcpPort && input.tcpPort.length > 0) {
-                        input.tcpPort.forEach(port => {
-                            command += ` --tcp=${port}`;
+                        input.tcpPort.forEach((port) => {
+                            args.push(`--tcp=${port}`);
                         });
                     }
                     break;
@@ -214,38 +229,38 @@ export async function kubectlCreate(k8sManager, input) {
                     if (!input.schedule) {
                         throw new McpError(ErrorCode.InvalidRequest, "schedule is required when creating a cronjob");
                     }
-                    command += ` cronjob ${input.name} --image=${input.image} --schedule="${input.schedule}"`;
+                    args.push("cronjob", input.name, `--image=${input.image}`, `--schedule=${input.schedule}`);
                     // Add command if specified
                     if (input.command && input.command.length > 0) {
-                        command += ` -- ${input.command.join(" ")}`;
+                        args.push("--", ...input.command);
                     }
                     // Add suspend flag if specified
                     if (input.suspend === true) {
-                        command += ` --suspend`;
+                        args.push(`--suspend`);
                     }
                     break;
                 case "deployment":
                     if (!input.image) {
                         throw new McpError(ErrorCode.InvalidRequest, "image is required when creating a deployment");
                     }
-                    command += ` deployment ${input.name} --image=${input.image}`;
+                    args.push("deployment", input.name, `--image=${input.image}`);
                     // Add replicas if specified
                     if (input.replicas) {
-                        command += ` --replicas=${input.replicas}`;
+                        args.push(`--replicas=${input.replicas}`);
                     }
                     // Add port if specified
                     if (input.port) {
-                        command += ` --port=${input.port}`;
+                        args.push(`--port=${input.port}`);
                     }
                     break;
                 case "job":
                     if (!input.image) {
                         throw new McpError(ErrorCode.InvalidRequest, "image is required when creating a job");
                     }
-                    command += ` job ${input.name} --image=${input.image}`;
+                    args.push("job", input.name, `--image=${input.image}`);
                     // Add command if specified
                     if (input.command && input.command.length > 0) {
-                        command += ` -- ${input.command.join(" ")}`;
+                        args.push("--", ...input.command);
                     }
                     break;
                 default:
@@ -254,33 +269,37 @@ export async function kubectlCreate(k8sManager, input) {
         }
         // Add namespace if not creating a namespace itself
         if (input.resourceType !== "namespace") {
-            command += ` -n ${namespace}`;
+            args.push("-n", namespace);
         }
         // Add labels if specified
         if (input.labels && input.labels.length > 0) {
-            input.labels.forEach(label => {
-                command += ` -l ${label}`;
+            input.labels.forEach((label) => {
+                args.push("-l", label);
             });
         }
         // Add annotations if specified
         if (input.annotations && input.annotations.length > 0) {
-            input.annotations.forEach(annotation => {
-                command += ` --annotation=${annotation}`;
+            input.annotations.forEach((annotation) => {
+                args.push(`--annotation=${annotation}`);
             });
         }
         // Add dry-run flag if requested
         if (dryRun) {
-            command += " --dry-run=client";
+            args.push("--dry-run=client");
         }
         // Add validate flag if needed
         if (!validate) {
-            command += " --validate=false";
+            args.push("--validate=false");
         }
         // Add output format
-        command += ` -o ${output}`;
+        args.push("-o", output);
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
+            const result = execFileSync(command, args, {
+                encoding: "utf8",
+                maxBuffer: getSpawnMaxBuffer(),
+                env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+            });
             // Clean up temp file if created
             if (tempFile) {
                 try {

package/dist/tools/kubectl-delete.js

@@ -1,8 +1,9 @@
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { getSpawnMaxBuffer } from "../config/max-buffer.js";
 export const kubectlDeleteSchema = {
     name: "kubectl_delete",
     description: "Delete Kubernetes resources by resource type, name, labels, or from a manifest file",
@@ -11,43 +12,43 @@ export const kubectlDeleteSchema = {
         properties: {
             resourceType: {
                 type: "string",
-                description: "Type of resource to delete (e.g., pods, deployments, services, etc.)"
+                description: "Type of resource to delete (e.g., pods, deployments, services, etc.)",
             },
             name: {
                 type: "string",
-                description: "Name of the resource to delete"
+                description: "Name of the resource to delete",
             },
             namespace: {
                 type: "string",
                 description: "Namespace of the resource (optional - defaults to 'default' for namespaced resources)",
-                default: "default"
+                default: "default",
             },
             labelSelector: {
                 type: "string",
-                description: "Delete resources matching this label selector (e.g. 'app=nginx')"
+                description: "Delete resources matching this label selector (e.g. 'app=nginx')",
             },
             manifest: {
                 type: "string",
-                description: "YAML manifest defining resources to delete (optional)"
+                description: "YAML manifest defining resources to delete (optional)",
             },
             filename: {
                 type: "string",
-                description: "Path to a YAML file to delete resources from (optional)"
+                description: "Path to a YAML file to delete resources from (optional)",
             },
             allNamespaces: {
                 type: "boolean",
                 description: "If true, delete resources across all namespaces",
-                default: false
+                default: false,
             },
             force: {
                 type: "boolean",
                 description: "If true, immediately remove resources from API and bypass graceful deletion",
-                default: false
+                default: false,
             },
             gracePeriodSeconds: {
                 type: "number",
-                description: "Period of time in seconds given to the resource to terminate gracefully"
-            }
+                description: "Period of time in seconds given to the resource to terminate gracefully",
+            },
         },
         required: ["resourceType", "name", "namespace"],
     },
@@ -65,7 +66,8 @@ export async function kubectlDelete(k8sManager, input) {
         const namespace = input.namespace || "default";
         const allNamespaces = input.allNamespaces || false;
         const force = input.force || false;
-        let command = "kubectl delete";
+        const command = "kubectl";
+        const args = ["delete"];
         let tempFile = null;
         // Handle deleting from manifest or file
         if (input.manifest) {
@@ -73,39 +75,45 @@ export async function kubectlDelete(k8sManager, input) {
             const tmpDir = os.tmpdir();
             tempFile = path.join(tmpDir, `delete-manifest-${Date.now()}.yaml`);
             fs.writeFileSync(tempFile, input.manifest);
-            command += ` -f ${tempFile}`;
+            args.push("-f", tempFile);
         }
         else if (input.filename) {
-            command += ` -f ${input.filename}`;
+            args.push("-f", input.filename);
         }
         else {
             // Handle deleting by resource type and name/selector
-            command += ` ${input.resourceType}`;
+            args.push(input.resourceType);
             if (input.name) {
-                command += ` ${input.name}`;
+                args.push(input.name);
             }
             if (input.labelSelector) {
-                command += ` -l ${input.labelSelector}`;
+                args.push("-l", input.labelSelector);
             }
         }
         // Add namespace flags
         if (allNamespaces) {
-            command += " --all-namespaces";
+            args.push("--all-namespaces");
         }
-        else if (namespace && input.resourceType && !isNonNamespacedResource(input.resourceType)) {
-            command += ` -n ${namespace}`;
+        else if (namespace &&
+            input.resourceType &&
+            !isNonNamespacedResource(input.resourceType)) {
+            args.push("-n", namespace);
         }
         // Add force flag if requested
         if (force) {
-            command += " --force";
+            args.push("--force");
         }
         // Add grace period if specified
         if (input.gracePeriodSeconds !== undefined) {
-            command += ` --grace-period=${input.gracePeriodSeconds}`;
+            args.push(`--grace-period=${input.gracePeriodSeconds}`);
         }
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
+            const result = execFileSync(command, args, {
+                encoding: "utf8",
+                maxBuffer: getSpawnMaxBuffer(),
+                env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+            });
             // Clean up temp file if created
             if (tempFile) {
                 try {
@@ -161,13 +169,21 @@ export async function kubectlDelete(k8sManager, input) {
 // Helper function to determine if a resource is non-namespaced
 function isNonNamespacedResource(resourceType) {
     const nonNamespacedResources = [
-        "nodes", "node", "no",
-        "namespaces", "namespace", "ns",
-        "persistentvolumes", "pv",
-        "storageclasses", "sc",
+        "nodes",
+        "node",
+        "no",
+        "namespaces",
+        "namespace",
+        "ns",
+        "persistentvolumes",
+        "pv",
+        "storageclasses",
+        "sc",
         "clusterroles",
         "clusterrolebindings",
-        "customresourcedefinitions", "crd", "crds"
+        "customresourcedefinitions",
+        "crd",
+        "crds",
     ];
     return nonNamespacedResources.includes(resourceType.toLowerCase());
 }

package/dist/tools/kubectl-describe.js

@@ -1,5 +1,6 @@
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { getSpawnMaxBuffer } from "../config/max-buffer.js";
 export const kubectlDescribeSchema = {
     name: "kubectl_describe",
     description: "Describe Kubernetes resources by resource type, name, and optionally namespace",
@@ -8,22 +9,22 @@ export const kubectlDescribeSchema = {
         properties: {
             resourceType: {
                 type: "string",
-                description: "Type of resource to describe (e.g., pods, deployments, services, etc.)"
+                description: "Type of resource to describe (e.g., pods, deployments, services, etc.)",
             },
             name: {
                 type: "string",
-                description: "Name of the resource to describe"
+                description: "Name of the resource to describe",
             },
             namespace: {
                 type: "string",
                 description: "Namespace of the resource (optional - defaults to 'default' for namespaced resources)",
-                default: "default"
+                default: "default",
             },
             allNamespaces: {
                 type: "boolean",
                 description: "If true, describe resources across all namespaces",
-                default: false
-            }
+                default: false,
+            },
         },
         required: ["resourceType", "name"],
     },
@@ -35,21 +36,22 @@ export async function kubectlDescribe(k8sManager, input) {
         const namespace = input.namespace || "default";
         const allNamespaces = input.allNamespaces || false;
         // Build the kubectl command
-        let command = "kubectl describe ";
-        // Add resource type
-        command += resourceType;
-        // Add name
-        command += ` ${name}`;
+        const command = "kubectl";
+        const args = ["describe", resourceType, name];
         // Add namespace flag unless all namespaces is specified
         if (allNamespaces) {
-            command += " --all-namespaces";
+            args.push("--all-namespaces");
         }
         else if (namespace && !isNonNamespacedResource(resourceType)) {
-            command += ` -n ${namespace}`;
+            args.push("-n", namespace);
         }
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
+            const result = execFileSync(command, args, {
+                encoding: "utf8",
+                maxBuffer: getSpawnMaxBuffer(),
+                env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+            });
             return {
                 content: [
                     {
@@ -84,13 +86,21 @@ export async function kubectlDescribe(k8sManager, input) {
 // Helper function to determine if a resource is non-namespaced
 function isNonNamespacedResource(resourceType) {
     const nonNamespacedResources = [
-        "nodes", "node", "no",
-        "namespaces", "namespace", "ns",
-        "persistentvolumes", "pv",
-        "storageclasses", "sc",
+        "nodes",
+        "node",
+        "no",
+        "namespaces",
+        "namespace",
+        "ns",
+        "persistentvolumes",
+        "pv",
+        "storageclasses",
+        "sc",
         "clusterroles",
         "clusterrolebindings",
-        "customresourcedefinitions", "crd", "crds"
+        "customresourcedefinitions",
+        "crd",
+        "crds",
     ];
     return nonNamespacedResources.includes(resourceType.toLowerCase());
 }