mcp-server-kubernetes 2.4.9 → 2.5.0

package/dist/tools/kubectl-rollout.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 kubectlRolloutSchema = {
     name: "kubectl_rollout",
     description: "Manage the rollout of a resource (e.g., deployment, daemonset, statefulset)",
@@ -10,86 +11,98 @@ export const kubectlRolloutSchema = {
                 type: "string",
                 description: "Rollout subcommand to execute",
                 enum: ["history", "pause", "restart", "resume", "status", "undo"],
-                default: "status"
+                default: "status",
             },
             resourceType: {
                 type: "string",
                 description: "Type of resource to manage rollout for",
                 enum: ["deployment", "daemonset", "statefulset"],
-                default: "deployment"
+                default: "deployment",
             },
             name: {
                 type: "string",
-                description: "Name of the resource"
+                description: "Name of the resource",
             },
             namespace: {
                 type: "string",
                 description: "Namespace of the resource",
-                default: "default"
+                default: "default",
             },
             revision: {
                 type: "number",
-                description: "Revision to rollback to (for undo subcommand)"
+                description: "Revision to rollback to (for undo subcommand)",
             },
             toRevision: {
                 type: "number",
-                description: "Revision to roll back to (for history subcommand)"
+                description: "Revision to roll back to (for history subcommand)",
             },
             timeout: {
                 type: "string",
-                description: "The length of time to wait before giving up (e.g., '30s', '1m', '2m30s')"
+                description: "The length of time to wait before giving up (e.g., '30s', '1m', '2m30s')",
             },
             watch: {
                 type: "boolean",
                 description: "Watch the rollout status in real-time until completion",
-                default: false
-            }
+                default: false,
+            },
         },
-        required: ["subCommand", "resourceType", "name", "namespace"]
-    }
+        required: ["subCommand", "resourceType", "name", "namespace"],
+    },
 };
 export async function kubectlRollout(k8sManager, input) {
     try {
         const namespace = input.namespace || "default";
         const watch = input.watch || false;
-        // Build the kubectl rollout command
-        let command = `kubectl rollout ${input.subCommand} ${input.resourceType}/${input.name} -n ${namespace}`;
+        const command = "kubectl";
+        const args = [
+            "rollout",
+            input.subCommand,
+            `${input.resourceType}/${input.name}`,
+            "-n",
+            namespace,
+        ];
         // Add revision for undo
         if (input.subCommand === "undo" && input.revision !== undefined) {
-            command += ` --to-revision=${input.revision}`;
+            args.push(`--to-revision=${input.revision}`);
         }
         // Add revision for history
         if (input.subCommand === "history" && input.toRevision !== undefined) {
-            command += ` --revision=${input.toRevision}`;
+            args.push(`--revision=${input.toRevision}`);
         }
         // Add timeout if specified
         if (input.timeout) {
-            command += ` --timeout=${input.timeout}`;
+            args.push(`--timeout=${input.timeout}`);
         }
         // Execute the command
         try {
             // For status command with watch flag, we need to handle it differently
             // since it's meant to be interactive and follow the progress
             if (input.subCommand === "status" && watch) {
-                command += " --watch";
+                args.push("--watch");
                 // For watch we are limited in what we can do - we'll execute it with a reasonable timeout
                 // and capture the output until that point
-                const result = execSync(command, {
+                const result = execFileSync(command, args, {
                     encoding: "utf8",
+                    maxBuffer: getSpawnMaxBuffer(),
                     timeout: 15000, // Reduced from 30 seconds to 15 seconds
-                    env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG }
+                    env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
                 });
                 return {
                     content: [
                         {
                             type: "text",
-                            text: result + "\n\nNote: Watch operation was limited to 15 seconds. The rollout may still be in progress.",
+                            text: result +
+                                "\n\nNote: Watch operation was limited to 15 seconds. The rollout may still be in progress.",
                         },
                     ],
                 };
             }
             else {
-                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: [
                         {

package/dist/tools/kubectl-scale.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 kubectlScaleSchema = {
     name: "kubectl_scale",
     description: "Scale a Kubernetes deployment",
@@ -8,42 +9,52 @@ export const kubectlScaleSchema = {
         properties: {
             name: {
                 type: "string",
-                description: "Name of the deployment to scale"
+                description: "Name of the deployment to scale",
             },
             namespace: {
                 type: "string",
                 description: "Namespace of the deployment",
-                default: "default"
+                default: "default",
             },
             replicas: {
                 type: "number",
-                description: "Number of replicas to scale to"
+                description: "Number of replicas to scale to",
             },
             resourceType: {
                 type: "string",
                 description: "Resource type to scale (deployment, replicaset, statefulset)",
-                default: "deployment"
-            }
+                default: "deployment",
+            },
         },
-        required: ["name", "replicas"]
-    }
+        required: ["name", "replicas"],
+    },
 };
 export async function kubectlScale(k8sManager, input) {
     try {
         const namespace = input.namespace || "default";
         const resourceType = input.resourceType || "deployment";
-        // Build the kubectl scale command
-        let command = `kubectl scale ${resourceType} ${input.name} --replicas=${input.replicas} --namespace=${namespace}`;
+        const command = "kubectl";
+        const args = [
+            "scale",
+            resourceType,
+            input.name,
+            `--replicas=${input.replicas}`,
+            `--namespace=${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: [
                     {
                         success: true,
-                        message: `Scaled ${resourceType} ${input.name} to ${input.replicas} replicas`
-                    }
-                ]
+                        message: `Scaled ${resourceType} ${input.name} to ${input.replicas} replicas`,
+                    },
+                ],
             };
         }
         catch (error) {
@@ -56,18 +67,18 @@ export async function kubectlScale(k8sManager, input) {
                 content: [
                     {
                         success: false,
-                        message: error.message
-                    }
-                ]
+                        message: error.message,
+                    },
+                ],
             };
         }
         return {
             content: [
                 {
                     success: false,
-                    message: `Failed to scale resource: ${error.message}`
-                }
-            ]
+                    message: `Failed to scale resource: ${error.message}`,
+                },
+            ],
         };
     }
 }

package/package.json

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