mcp-server-kubernetes 2.4.7 → 2.5.0

package/dist/tools/kubectl-generic.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 kubectlGenericSchema = {
     name: "kubectl_generic",
     description: "Execute any kubectl command with the provided arguments and flags",
@@ -8,48 +9,49 @@ export const kubectlGenericSchema = {
         properties: {
             command: {
                 type: "string",
-                description: "The kubectl command to execute (e.g. patch, rollout, top)"
+                description: "The kubectl command to execute (e.g. patch, rollout, top)",
             },
             subCommand: {
                 type: "string",
-                description: "Subcommand if applicable (e.g. 'history' for rollout)"
+                description: "Subcommand if applicable (e.g. 'history' for rollout)",
             },
             resourceType: {
                 type: "string",
-                description: "Resource type (e.g. pod, deployment)"
+                description: "Resource type (e.g. pod, deployment)",
             },
             name: {
                 type: "string",
-                description: "Resource name"
+                description: "Resource name",
             },
             namespace: {
                 type: "string",
                 description: "Namespace",
-                default: "default"
+                default: "default",
             },
             outputFormat: {
                 type: "string",
                 description: "Output format (e.g. json, yaml, wide)",
-                enum: ["json", "yaml", "wide", "name", "custom"]
+                enum: ["json", "yaml", "wide", "name", "custom"],
             },
             flags: {
                 type: "object",
                 description: "Command flags as key-value pairs",
-                additionalProperties: true
+                additionalProperties: true,
             },
             args: {
                 type: "array",
                 items: { type: "string" },
-                description: "Additional command arguments"
-            }
+                description: "Additional command arguments",
+            },
         },
-        required: ["command"]
-    }
+        required: ["command"],
+    },
 };
 export async function kubectlGeneric(k8sManager, input) {
     try {
         // Start building the kubectl command
-        let cmdArgs = ["kubectl", input.command];
+        const command = "kubectl";
+        const cmdArgs = [input.command];
         // Add subcommand if provided
         if (input.subCommand) {
             cmdArgs.push(input.subCommand);
@@ -87,11 +89,14 @@ export async function kubectlGeneric(k8sManager, input) {
         if (input.args && input.args.length > 0) {
             cmdArgs.push(...input.args);
         }
-        // Execute the command (join all args except the first "kubectl" which is used in execSync)
-        const command = cmdArgs.slice(1).join(' ');
+        // Execute the command
         try {
-            console.error(`Executing: kubectl ${command}`);
-            const result = execSync(`kubectl ${command}`, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
+            console.error(`Executing: kubectl ${cmdArgs.join(" ")}`);
+            const result = execFileSync(command, cmdArgs, {
+                encoding: "utf8",
+                maxBuffer: getSpawnMaxBuffer(),
+                env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+            });
             return {
                 content: [
                     {

package/dist/tools/kubectl-get.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 kubectlGetSchema = {
     name: "kubectl_get",
     description: "Get or list Kubernetes resources by resource type, name, and optionally namespace",
@@ -32,15 +33,15 @@ export const kubectlGetSchema = {
             },
             labelSelector: {
                 type: "string",
-                description: "Filter resources by label selector (e.g. 'app=nginx')"
+                description: "Filter resources by label selector (e.g. 'app=nginx')",
             },
             fieldSelector: {
                 type: "string",
-                description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')"
+                description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')",
             },
             sortBy: {
                 type: "string",
-                description: "Sort events by a field (default: lastTimestamp). Only applicable for events."
+                description: "Sort events by a field (default: lastTimestamp). Only applicable for events.",
             },
         },
         required: ["resourceType", "name", "namespace"],
@@ -57,12 +58,11 @@ export async function kubectlGet(k8sManager, input) {
         const fieldSelector = input.fieldSelector || "";
         const sortBy = input.sortBy;
         // Build the kubectl command
-        let command = "kubectl get ";
-        // Add resource type
-        command += resourceType;
+        const command = "kubectl";
+        const args = ["get", resourceType];
         // Add name if provided
         if (name) {
-            command += ` ${name}`;
+            args.push(name);
         }
         // For events, default to all namespaces unless explicitly specified
         const shouldShowAllNamespaces = resourceType === "events"
@@ -72,51 +72,52 @@ export async function kubectlGet(k8sManager, input) {
             : allNamespaces;
         // Add namespace flag unless all namespaces is specified
         if (shouldShowAllNamespaces) {
-            command += " --all-namespaces";
+            args.push("--all-namespaces");
         }
         else if (namespace && !isNonNamespacedResource(resourceType)) {
-            command += ` -n ${namespace}`;
+            args.push("-n", namespace);
         }
         // Add label selector if provided
         if (labelSelector) {
-            command += ` -l ${labelSelector}`;
+            args.push("-l", labelSelector);
         }
         // Add field selector if provided
         if (fieldSelector) {
-            command += ` --field-selector=${fieldSelector}`;
+            args.push(`--field-selector=${fieldSelector}`);
         }
         // Add sort-by for events
         if (resourceType === "events" && sortBy) {
-            command += ` --sort-by=.${sortBy}`;
+            args.push(`--sort-by=.${sortBy}`);
         }
         else if (resourceType === "events") {
-            command += ` --sort-by=.lastTimestamp`;
+            args.push(`--sort-by=.lastTimestamp`);
         }
         // Add output format
         if (output === "json") {
-            command += " -o json";
+            args.push("-o", "json");
         }
         else if (output === "yaml") {
-            command += " -o yaml";
+            args.push("-o", "yaml");
         }
         else if (output === "wide") {
-            command += " -o wide";
+            args.push("-o", "wide");
         }
         else if (output === "name") {
-            command += " -o name";
+            args.push("-o", "name");
         }
         else if (output === "custom") {
             if (resourceType === "events") {
-                command += ` -o 'custom-columns=LAST SEEN:.lastTimestamp,TYPE:.type,REASON:.reason,OBJECT:.involvedObject.kind/.involvedObject.name,MESSAGE:.message'`;
+                args.push("-o", "'custom-columns=LASTSEEN:.lastTimestamp,TYPE:.type,REASON:.reason,OBJECT:.involvedObject.name,MESSAGE:.message'");
             }
             else {
-                command += ` -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
         try {
-            const result = execSync(command, {
+            const result = execFileSync(command, args, {
                 encoding: "utf8",
+                maxBuffer: getSpawnMaxBuffer(),
                 env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
             });
             // Format the results for better readability

package/dist/tools/kubectl-logs.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 kubectlLogsSchema = {
     name: "kubectl_logs",
     description: "Get logs from Kubernetes resources like pods, deployments, or jobs",
@@ -22,19 +23,19 @@ export const kubectlLogsSchema = {
             },
             container: {
                 type: "string",
-                description: "Container name (required when pod has multiple containers)"
+                description: "Container name (required when pod has multiple containers)",
             },
             tail: {
                 type: "number",
-                description: "Number of lines to show from end of logs"
+                description: "Number of lines to show from end of logs",
             },
             since: {
                 type: "string",
-                description: "Show logs since relative time (e.g. '5s', '2m', '3h')"
+                description: "Show logs since relative time (e.g. '5s', '2m', '3h')",
             },
             sinceTime: {
                 type: "string",
-                description: "Show logs since absolute time (RFC3339)"
+                description: "Show logs since absolute time (RFC3339)",
             },
             timestamps: {
                 type: "boolean",
@@ -53,8 +54,8 @@ export const kubectlLogsSchema = {
             },
             labelSelector: {
                 type: "string",
-                description: "Filter resources by label selector"
-            }
+                description: "Filter resources by label selector",
+            },
         },
         required: ["resourceType", "name", "namespace"],
     },
@@ -64,32 +65,45 @@ export async function kubectlLogs(k8sManager, input) {
         const resourceType = input.resourceType.toLowerCase();
         const name = input.name;
         const namespace = input.namespace || "default";
-        // Build the kubectl command base
-        let baseCommand = `kubectl -n ${namespace}`;
+        const command = "kubectl";
         // Handle different resource types
         if (resourceType === "pod") {
             // Direct pod logs
-            baseCommand += ` logs ${name}`;
+            let args = ["-n", namespace, "logs", name];
             // If container is specified, add it
             if (input.container) {
-                baseCommand += ` -c ${input.container}`;
+                args.push(`-c`, input.container);
             }
             // Add options
-            baseCommand = addLogOptions(baseCommand, input);
+            args = addLogOptions(args, input);
             // Execute the command
             try {
-                const result = execSync(baseCommand, { 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 formatLogOutput(name, result);
             }
             catch (error) {
                 return handleCommandError(error, `pod ${name}`);
             }
         }
-        else if (resourceType === "deployment" || resourceType === "job" || resourceType === "cronjob") {
+        else if (resourceType === "deployment" ||
+            resourceType === "job" ||
+            resourceType === "cronjob") {
             // For deployments, jobs and cronjobs we need to find the pods first
-            let selectorCommand;
+            let selectorArgs;
             if (resourceType === "deployment") {
-                selectorCommand = `kubectl -n ${namespace} get deployment ${name} -o jsonpath='{.spec.selector.matchLabels}'`;
+                selectorArgs = [
+                    "-n",
+                    namespace,
+                    "get",
+                    "deployment",
+                    name,
+                    "-o",
+                    "jsonpath='{.spec.selector.matchLabels}'",
+                ];
             }
             else if (resourceType === "job") {
                 // For jobs, we use the job-name label
@@ -97,10 +111,24 @@ export async function kubectlLogs(k8sManager, input) {
             }
             else if (resourceType === "cronjob") {
                 // For cronjobs, it's more complex - need to find the job first
-                const jobsCommand = `kubectl -n ${namespace} get jobs --selector=job-name=${name} -o jsonpath='{.items[*].metadata.name}'`;
+                const jobsArgs = [
+                    "-n",
+                    namespace,
+                    "get",
+                    "jobs",
+                    "--selector=job-name=" + name,
+                    "-o",
+                    "jsonpath='{.items[*].metadata.name}'",
+                ];
                 try {
-                    const jobs = execSync(jobsCommand, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } }).trim().split(' ');
-                    if (jobs.length === 0 || (jobs.length === 1 && jobs[0] === '')) {
+                    const jobs = execFileSync(command, jobsArgs, {
+                        encoding: "utf8",
+                        maxBuffer: getSpawnMaxBuffer(),
+                        env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+                    })
+                        .trim()
+                        .split(" ");
+                    if (jobs.length === 0 || (jobs.length === 1 && jobs[0] === "")) {
                         return {
                             content: [
                                 {
@@ -140,15 +168,19 @@ export async function kubectlLogs(k8sManager, input) {
             try {
                 if (resourceType === "deployment") {
                     // Get the deployment's selector
-                    if (!selectorCommand) {
+                    if (!selectorArgs) {
                         throw new Error("Selector command is undefined");
                     }
-                    const selectorJson = execSync(selectorCommand, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } }).trim();
+                    const selectorJson = execFileSync(command, selectorArgs, {
+                        encoding: "utf8",
+                        maxBuffer: getSpawnMaxBuffer(),
+                        env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+                    }).trim();
                     const selector = JSON.parse(selectorJson.replace(/'/g, '"'));
                     // Convert to label selector format
                     const labelSelector = Object.entries(selector)
                         .map(([key, value]) => `${key}=${value}`)
-                        .join(',');
+                        .join(",");
                     return getLabelSelectorLogs(labelSelector, namespace, input);
                 }
                 // For jobs and cronjobs, the logic is handled above
@@ -183,36 +215,50 @@ export async function kubectlLogs(k8sManager, input) {
     }
 }
 // Helper function to add log options to the kubectl command
-function addLogOptions(baseCommand, input) {
-    let command = baseCommand;
+function addLogOptions(args, input) {
     // Add options based on inputs
     if (input.tail !== undefined) {
-        command += ` --tail=${input.tail}`;
+        args.push(`--tail=${input.tail}`);
     }
     if (input.since) {
-        command += ` --since=${input.since}`;
+        args.push(`--since=${input.since}`);
     }
     if (input.sinceTime) {
-        command += ` --since-time=${input.sinceTime}`;
+        args.push(`--since-time=${input.sinceTime}`);
     }
     if (input.timestamps) {
-        command += ` --timestamps`;
+        args.push(`--timestamps`);
     }
     if (input.previous) {
-        command += ` --previous`;
+        args.push(`--previous`);
     }
     if (input.follow) {
-        command += ` --follow`;
+        args.push(`--follow`);
     }
-    return command;
+    return args;
 }
 // Helper function to get logs for resources selected by labels
 async function getLabelSelectorLogs(labelSelector, namespace, input) {
     try {
+        const command = "kubectl";
         // First, find all pods matching the label selector
-        const podsCommand = `kubectl -n ${namespace} get pods --selector=${labelSelector} -o jsonpath='{.items[*].metadata.name}'`;
-        const pods = execSync(podsCommand, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } }).trim().split(' ');
-        if (pods.length === 0 || (pods.length === 1 && pods[0] === '')) {
+        const podsArgs = [
+            "-n",
+            namespace,
+            "get",
+            "pods",
+            `--selector=${labelSelector}`,
+            "-o",
+            "jsonpath='{.items[*].metadata.name}'",
+        ];
+        const pods = execFileSync(command, podsArgs, {
+            encoding: "utf8",
+            maxBuffer: getSpawnMaxBuffer(),
+            env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+        })
+            .trim()
+            .split(" ");
+        if (pods.length === 0 || (pods.length === 1 && pods[0] === "")) {
             return {
                 content: [
                     {
@@ -230,15 +276,19 @@ async function getLabelSelectorLogs(labelSelector, namespace, input) {
             // Skip empty pod names
             if (!pod)
                 continue;
-            let podCommand = `kubectl -n ${namespace} logs ${pod}`;
+            let podArgs = ["-n", namespace, "logs", pod];
             // Add container if specified
             if (input.container) {
-                podCommand += ` -c ${input.container}`;
+                podArgs.push(`-c`, input.container);
             }
             // Add other options
-            podCommand = addLogOptions(podCommand, input);
+            podArgs = addLogOptions(podArgs, input);
             try {
-                const logs = execSync(podCommand, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
+                const logs = execFileSync(command, podArgs, {
+                    encoding: "utf8",
+                    maxBuffer: getSpawnMaxBuffer(),
+                    env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+                });
                 logsMap[pod] = logs;
             }
             catch (error) {
@@ -299,9 +349,13 @@ function handleCommandError(error, resourceDescription) {
         const podNameMatch = error.message.match(/for pod ([^,]+)/);
         const containersMatch = error.message.match(/choose one of: \[([^\]]+)\]/);
         const initContainersMatch = error.message.match(/or one of the init containers: \[([^\]]+)\]/);
-        const podName = podNameMatch ? podNameMatch[1] : 'unknown';
-        const containers = containersMatch ? containersMatch[1].split(' ').map((c) => c.trim()) : [];
-        const initContainers = initContainersMatch ? initContainersMatch[1].split(' ').map((c) => c.trim()) : [];
+        const podName = podNameMatch ? podNameMatch[1] : "unknown";
+        const containers = containersMatch
+            ? containersMatch[1].split(" ").map((c) => c.trim())
+            : [];
+        const initContainers = initContainersMatch
+            ? initContainersMatch[1].split(" ").map((c) => c.trim())
+            : [];
         // Generate structured context for the MCP client to make decisions
         const context = {
             error: "Multi-container pod requires container specification",
@@ -309,7 +363,9 @@ function handleCommandError(error, resourceDescription) {
             pod_name: podName,
             available_containers: containers,
             init_containers: initContainers,
-            suggestion: `Please specify a container name using the 'container' parameter. Available containers: ${containers.join(', ')}${initContainers.length > 0 ? `. Init containers: ${initContainers.join(', ')}` : ''}`
+            suggestion: `Please specify a container name using the 'container' parameter. Available containers: ${containers.join(", ")}${initContainers.length > 0
+                ? `. Init containers: ${initContainers.join(", ")}`
+                : ""}`,
         };
         return {
             content: [
@@ -328,7 +384,7 @@ function handleCommandError(error, resourceDescription) {
                 text: JSON.stringify({
                     error: `Failed to get logs for ${resourceDescription}: ${error.message}`,
                     status: "general_error",
-                    original_error: error.message
+                    original_error: error.message,
                 }, null, 2),
             },
         ],

package/dist/tools/kubectl-operations.js

@@ -1,4 +1,5 @@
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
+import { getSpawnMaxBuffer } from "../config/max-buffer.js";
 export const explainResourceSchema = {
     name: "explain_resource",
     description: "Get documentation for a Kubernetes resource or field",
@@ -58,9 +59,13 @@ export const listApiResourcesSchema = {
         },
     },
 };
-const executeKubectlCommand = (command) => {
+const executeKubectlCommand = (command, args) => {
     try {
-        return execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
+        return execFileSync(command, args, {
+            encoding: "utf8",
+            maxBuffer: getSpawnMaxBuffer(),
+            env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+        });
     }
     catch (error) {
         throw new Error(`Kubectl command failed: ${error.message}`);
@@ -68,18 +73,19 @@ const executeKubectlCommand = (command) => {
 };
 export async function explainResource(params) {
     try {
-        let command = "kubectl explain";
+        const command = "kubectl";
+        const args = ["explain"];
         if (params.apiVersion) {
-            command += ` --api-version=${params.apiVersion}`;
+            args.push(`--api-version=${params.apiVersion}`);
         }
         if (params.recursive) {
-            command += " --recursive";
+            args.push("--recursive");
         }
         if (params.output) {
-            command += ` --output=${params.output}`;
+            args.push(`--output=${params.output}`);
         }
-        command += ` ${params.resource}`;
-        const result = executeKubectlCommand(command);
+        args.push(params.resource);
+        const result = executeKubectlCommand(command, args);
         return {
             content: [
                 {
@@ -95,20 +101,21 @@ export async function explainResource(params) {
 }
 export async function listApiResources(params) {
     try {
-        let command = "kubectl api-resources";
+        const command = "kubectl";
+        const args = ["api-resources"];
         if (params.apiGroup) {
-            command += ` --api-group=${params.apiGroup}`;
+            args.push(`--api-group=${params.apiGroup}`);
         }
         if (params.namespaced !== undefined) {
-            command += ` --namespaced=${params.namespaced}`;
+            args.push(`--namespaced=${params.namespaced}`);
         }
         if (params.verbs && params.verbs.length > 0) {
-            command += ` --verbs=${params.verbs.join(",")}`;
+            args.push(`--verbs=${params.verbs.join(",")}`);
         }
         if (params.output) {
-            command += ` -o ${params.output}`;
+            args.push(`-o`, params.output);
         }
-        const result = executeKubectlCommand(command);
+        const result = executeKubectlCommand(command, args);
         return {
             content: [
                 {

package/dist/tools/kubectl-patch.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 kubectlPatchSchema = {
     name: "kubectl_patch",
     description: "Update field(s) of a resource using strategic merge patch, JSON merge patch, or JSON patch",
@@ -11,39 +12,39 @@ export const kubectlPatchSchema = {
         properties: {
             resourceType: {
                 type: "string",
-                description: "Type of resource to patch (e.g., pods, deployments, services)"
+                description: "Type of resource to patch (e.g., pods, deployments, services)",
             },
             name: {
                 type: "string",
-                description: "Name of the resource to patch"
+                description: "Name of the resource to patch",
             },
             namespace: {
                 type: "string",
                 description: "Namespace of the resource",
-                default: "default"
+                default: "default",
             },
             patchType: {
                 type: "string",
                 description: "Type of patch to apply",
                 enum: ["strategic", "merge", "json"],
-                default: "strategic"
+                default: "strategic",
             },
             patchData: {
                 type: "object",
-                description: "Patch data as a JSON object"
+                description: "Patch data as a JSON object",
             },
             patchFile: {
                 type: "string",
-                description: "Path to a file containing the patch data (alternative to patchData)"
+                description: "Path to a file containing the patch data (alternative to patchData)",
             },
             dryRun: {
                 type: "boolean",
                 description: "If true, only print the object that would be sent, without sending it",
-                default: false
-            }
+                default: false,
+            },
         },
         required: ["resourceType", "name"],
-    }
+    },
 };
 export async function kubectlPatch(k8sManager, input) {
     try {
@@ -54,21 +55,21 @@ export async function kubectlPatch(k8sManager, input) {
         const patchType = input.patchType || "strategic";
         const dryRun = input.dryRun || false;
         let tempFile = null;
-        // Build the kubectl patch command
-        let command = `kubectl patch ${input.resourceType} ${input.name} -n ${namespace}`;
+        const command = "kubectl";
+        const args = ["patch", input.resourceType, input.name, "-n", namespace];
         // Add patch type flag
         switch (patchType) {
             case "strategic":
-                command += " --type strategic";
+                args.push("--type", "strategic");
                 break;
             case "merge":
-                command += " --type merge";
+                args.push("--type", "merge");
                 break;
             case "json":
-                command += " --type json";
+                args.push("--type", "json");
                 break;
             default:
-                command += " --type strategic";
+                args.push("--type", "strategic");
         }
         // Handle patch data
         if (input.patchData) {
@@ -76,18 +77,22 @@ export async function kubectlPatch(k8sManager, input) {
             const tmpDir = os.tmpdir();
             tempFile = path.join(tmpDir, `patch-${Date.now()}.json`);
             fs.writeFileSync(tempFile, JSON.stringify(input.patchData));
-            command += ` --patch-file ${tempFile}`;
+            args.push("--patch-file", tempFile);
         }
         else if (input.patchFile) {
-            command += ` --patch-file ${input.patchFile}`;
+            args.push("--patch-file", input.patchFile);
         }
         // Add dry-run flag if requested
         if (dryRun) {
-            command += " --dry-run=client";
+            args.push("--dry-run=client");
         }
         // 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 {