mcp-server-kubernetes 2.7.0 → 2.9.0

package/dist/tools/helm-operations.js

@@ -1,227 +1,418 @@
+/**
+ * Tool: install_helm_chart
+ * Install a Helm chart with support for both standard Helm install and template-based installation.
+ * Template mode bypasses authentication issues and kubeconfig API version mismatches.
+ * Supports local chart paths, remote repositories, and custom values.
+ */
 import { execFileSync } from "child_process";
 import { writeFileSync, unlinkSync } from "fs";
-import yaml from "yaml";
+import { dump } from "js-yaml";
 import { getSpawnMaxBuffer } from "../config/max-buffer.js";
+import { contextParameter, namespaceParameter } from "../models/common-parameters.js";
+/**
+ * Schema for install_helm_chart tool.
+ * - name: Release name
+ * - chart: Chart name or path to chart directory
+ * - namespace: Target namespace
+ * - repo: (Optional) Helm repository URL
+ * - values: (Optional) Custom values object
+ * - valuesFile: (Optional) Path to values file
+ * - useTemplate: (Optional) Use template mode instead of helm install
+ * - createNamespace: (Optional) Create namespace if it doesn't exist
+ */
 export const installHelmChartSchema = {
     name: "install_helm_chart",
-    description: "Install a Helm chart",
+    description: "Install a Helm chart with support for both standard and template-based installation",
     inputSchema: {
         type: "object",
         properties: {
             name: {
                 type: "string",
-                description: "Release name",
+                description: "Name of the Helm release",
             },
             chart: {
                 type: "string",
-                description: "Chart name",
+                description: "Chart name (e.g., 'nginx') or path to chart directory",
             },
+            namespace: namespaceParameter,
+            context: contextParameter,
             repo: {
                 type: "string",
-                description: "Chart repository URL",
-            },
-            namespace: {
-                type: "string",
-                description: "Kubernetes namespace",
+                description: "Helm repository URL (optional if using local chart path)",
             },
             values: {
                 type: "object",
-                description: "Chart values",
-                properties: {},
-                additionalProperties: true,
+                description: "Custom values to override chart defaults",
+            },
+            valuesFile: {
+                type: "string",
+                description: "Path to values file (alternative to values object)",
+            },
+            useTemplate: {
+                type: "boolean",
+                description: "Use helm template + kubectl apply instead of helm install (bypasses auth issues)",
+                default: false,
+            },
+            createNamespace: {
+                type: "boolean",
+                description: "Create namespace if it doesn't exist",
+                default: true,
             },
         },
-        required: ["name", "chart", "repo", "namespace"],
+        required: ["name", "chart", "namespace"],
     },
 };
+/**
+ * Schema for upgrade_helm_chart tool.
+ * - name: Release name
+ * - chart: Chart name or path
+ * - namespace: Target namespace
+ * - repo: (Optional) Helm repository URL
+ * - values: (Optional) Custom values object
+ * - valuesFile: (Optional) Path to values file
+ */
 export const upgradeHelmChartSchema = {
     name: "upgrade_helm_chart",
-    description: "Upgrade a Helm release",
+    description: "Upgrade an existing Helm chart release",
     inputSchema: {
         type: "object",
         properties: {
             name: {
                 type: "string",
-                description: "Release name",
+                description: "Name of the Helm release to upgrade",
             },
             chart: {
                 type: "string",
-                description: "Chart name",
+                description: "Chart name or path to chart directory",
             },
+            namespace: namespaceParameter,
+            context: contextParameter,
             repo: {
                 type: "string",
-                description: "Chart repository URL",
-            },
-            namespace: {
-                type: "string",
-                description: "Kubernetes namespace",
+                description: "Helm repository URL (optional if using local chart path)",
             },
             values: {
                 type: "object",
-                description: "Chart values",
-                properties: {},
-                additionalProperties: true,
+                description: "Custom values to override chart defaults",
+            },
+            valuesFile: {
+                type: "string",
+                description: "Path to values file (alternative to values object)",
             },
         },
-        required: ["name", "chart", "repo", "namespace"],
+        required: ["name", "chart", "namespace"],
     },
 };
+/**
+ * Schema for uninstall_helm_chart tool.
+ * - name: Release name
+ * - namespace: Target namespace
+ */
 export const uninstallHelmChartSchema = {
     name: "uninstall_helm_chart",
-    description: "Uninstall a Helm release",
+    description: "Uninstall a Helm chart release",
     inputSchema: {
         type: "object",
         properties: {
             name: {
                 type: "string",
-                description: "Release name",
-            },
-            namespace: {
-                type: "string",
-                description: "Kubernetes namespace",
+                description: "Name of the Helm release to uninstall",
             },
+            namespace: namespaceParameter,
+            context: contextParameter,
         },
         required: ["name", "namespace"],
     },
 };
-const executeHelmCommand = (command, args) => {
+/**
+ * Execute a command using child_process.execFileSync with proper error handling.
+ * @param command - The command to execute
+ * @param args - Array of command arguments
+ * @returns The command output as a string
+ * @throws Error if command execution fails
+ */
+const executeCommand = (command, args) => {
     try {
-        // Add a generous timeout of 60 seconds for Helm operations
         return execFileSync(command, args, {
             encoding: "utf8",
-            timeout: 60000, // 60 seconds timeout
+            timeout: 300000, // 5 minutes timeout
             maxBuffer: getSpawnMaxBuffer(),
             env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
         });
     }
     catch (error) {
-        throw new Error(`Helm command failed: ${error.message}`);
+        throw new Error(`${command} command failed: ${error.message}`);
     }
 };
-const writeValuesFile = (name, values) => {
-    const filename = `${name}-values.yaml`;
-    writeFileSync(filename, yaml.stringify(values));
-    return filename;
-};
-export async function installHelmChart(params) {
+/**
+ * Install a Helm chart using template mode (helm template + kubectl apply).
+ * This mode bypasses authentication issues and kubeconfig API version mismatches.
+ * @param params - Installation parameters
+ * @returns Promise with installation result
+ */
+async function installHelmChartTemplate(params) {
+    const steps = [];
     try {
-        // Add helm repository if provided
+        // Step 1: Add helm repository if provided
         if (params.repo) {
-            const repoName = params.chart.split("/")[0];
-            executeHelmCommand("helm", ["repo", "add", repoName, params.repo]);
-            executeHelmCommand("helm", ["repo", "update"]);
+            steps.push(`Adding helm repository: ${params.repo}`);
+            executeCommand("helm", ["repo", "add", "temp-repo", params.repo]);
+            executeCommand("helm", ["repo", "update"]);
+        }
+        // Step 2: Create namespace
+        steps.push(`Creating namespace: ${params.namespace}`);
+        try {
+            executeCommand("kubectl", ["create", "namespace", params.namespace]);
+        }
+        catch (error) {
+            if (!error.message.includes("already exists")) {
+                throw error;
+            }
+            steps.push(`Namespace ${params.namespace} already exists`);
+        }
+        // Step 3: Prepare values
+        let valuesContent = "";
+        if (params.valuesFile) {
+            steps.push(`Using values file: ${params.valuesFile}`);
+            valuesContent = executeCommand("cat", [params.valuesFile]);
+        }
+        else if (params.values) {
+            steps.push("Using provided values object");
+            valuesContent = dump(params.values);
         }
-        let command = "helm";
-        let args = [
-            "install",
+        // Step 4: Generate YAML using helm template
+        steps.push("Generating YAML using helm template");
+        const templateArgs = [
+            "template",
             params.name,
             params.chart,
-            "--namespace",
-            params.namespace,
-            "--create-namespace",
+            "--namespace", params.namespace
         ];
-        // Handle values if provided
-        if (params.values) {
-            const valuesFile = writeValuesFile(params.name, params.values);
-            args.push("-f", valuesFile);
+        if (params.repo) {
+            templateArgs.push("--repo", params.repo);
+        }
+        if (valuesContent) {
+            const tempValuesFile = `/tmp/values-${Date.now()}.yaml`;
+            writeFileSync(tempValuesFile, valuesContent);
+            templateArgs.push("-f", tempValuesFile);
+            const yamlOutput = executeCommand("helm", templateArgs);
+            // Clean up temp file
+            unlinkSync(tempValuesFile);
+            // Step 5: Apply YAML using kubectl
+            steps.push("Applying YAML using kubectl");
+            const tempYamlFile = `/tmp/helm-template-${Date.now()}.yaml`;
+            writeFileSync(tempYamlFile, yamlOutput);
             try {
-                executeHelmCommand(command, args);
+                executeCommand("kubectl", ["apply", "-f", tempYamlFile]);
+                steps.push("Helm chart installed successfully using template mode");
             }
             finally {
-                // Cleanup values file
-                unlinkSync(valuesFile);
+                // Clean up temp file
+                unlinkSync(tempYamlFile);
             }
         }
         else {
-            executeHelmCommand(command, args);
+            const yamlOutput = executeCommand("helm", templateArgs);
+            // Step 5: Apply YAML using kubectl
+            steps.push("Applying YAML using kubectl");
+            const tempYamlFile = `/tmp/helm-template-${Date.now()}.yaml`;
+            writeFileSync(tempYamlFile, yamlOutput);
+            try {
+                executeCommand("kubectl", ["apply", "-f", tempYamlFile]);
+                steps.push("Helm chart installed successfully using template mode");
+            }
+            finally {
+                // Clean up temp file
+                unlinkSync(tempYamlFile);
+            }
         }
-        const response = {
-            status: "installed",
-            message: `Successfully installed ${params.name}`,
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "installed",
+                        message: `Helm chart '${params.name}' installed successfully using template mode`,
+                        steps: steps
+                    })
+                }
+            ]
         };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "failed",
+                        error: `Failed to install Helm chart using template mode: ${error.message}`,
+                        steps: steps
+                    })
+                }
+            ]
+        };
+    }
+}
+/**
+ * Install a Helm chart using standard helm install command.
+ * @param params - Installation parameters
+ * @returns Promise with installation result
+ */
+export async function installHelmChart(params) {
+    // Use template mode if requested
+    if (params.useTemplate) {
+        return installHelmChartTemplate(params);
+    }
+    try {
+        // Add repository if provided
+        if (params.repo) {
+            const repoName = params.chart.split("/")[0];
+            executeCommand("helm", ["repo", "add", repoName, params.repo]);
+            executeCommand("helm", ["repo", "update"]);
+        }
+        const args = ["install", params.name, params.chart, "--namespace", params.namespace];
+        // Add create namespace flag if requested
+        if (params.createNamespace !== false) {
+            args.push("--create-namespace");
+        }
+        // Add values file if provided
+        if (params.valuesFile) {
+            args.push("-f", params.valuesFile);
+        }
+        // Add values object if provided
+        if (params.values) {
+            const valuesContent = dump(params.values);
+            const tempFile = `/tmp/values-${Date.now()}.yaml`;
+            writeFileSync(tempFile, valuesContent);
+            try {
+                args.push("-f", tempFile);
+                executeCommand("helm", args);
+            }
+            finally {
+                unlinkSync(tempFile);
+            }
+        }
+        else {
+            executeCommand("helm", args);
+        }
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
+                    text: JSON.stringify({
+                        status: "installed",
+                        message: `Helm chart '${params.name}' installed successfully in namespace '${params.namespace}'`
+                    })
+                }
+            ]
         };
     }
     catch (error) {
-        throw new Error(`Failed to install Helm chart: ${error.message}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "failed",
+                        error: `Failed to install Helm chart: ${error.message}`
+                    })
+                }
+            ]
+        };
     }
 }
+/**
+ * Upgrade an existing Helm chart release.
+ * @param params - Upgrade parameters
+ * @returns Promise with upgrade result
+ */
 export async function upgradeHelmChart(params) {
     try {
-        // Add helm repository if provided
+        // Add repository if provided
         if (params.repo) {
             const repoName = params.chart.split("/")[0];
-            executeHelmCommand("helm", ["repo", "add", repoName, params.repo]);
-            executeHelmCommand("helm", ["repo", "update"]);
+            executeCommand("helm", ["repo", "add", repoName, params.repo]);
+            executeCommand("helm", ["repo", "update"]);
         }
-        let command = "helm";
-        let args = [
-            "upgrade",
-            params.name,
-            params.chart,
-            "--namespace",
-            params.namespace,
-        ];
-        // Handle values if provided
+        const args = ["upgrade", params.name, params.chart, "--namespace", params.namespace];
+        // Add values file if provided
+        if (params.valuesFile) {
+            args.push("-f", params.valuesFile);
+        }
+        // Add values object if provided
         if (params.values) {
-            const valuesFile = writeValuesFile(params.name, params.values);
-            args.push("-f", valuesFile);
+            const valuesContent = dump(params.values);
+            const tempFile = `/tmp/values-${Date.now()}.yaml`;
+            writeFileSync(tempFile, valuesContent);
             try {
-                executeHelmCommand(command, args);
+                args.push("-f", tempFile);
+                executeCommand("helm", args);
             }
             finally {
-                // Cleanup values file
-                unlinkSync(valuesFile);
+                unlinkSync(tempFile);
             }
         }
         else {
-            executeHelmCommand(command, args);
+            executeCommand("helm", args);
         }
-        const response = {
-            status: "upgraded",
-            message: `Successfully upgraded ${params.name}`,
-        };
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
+                    text: JSON.stringify({
+                        status: "upgraded",
+                        message: `Helm chart '${params.name}' upgraded successfully in namespace '${params.namespace}'`
+                    })
+                }
+            ]
         };
     }
     catch (error) {
-        throw new Error(`Failed to upgrade Helm chart: ${error.message}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "failed",
+                        error: `Failed to upgrade Helm chart: ${error.message}`
+                    })
+                }
+            ]
+        };
     }
 }
+/**
+ * Uninstall a Helm chart release.
+ * @param params - Uninstall parameters
+ * @returns Promise with uninstall result
+ */
 export async function uninstallHelmChart(params) {
     try {
-        executeHelmCommand("helm", [
-            "uninstall",
-            params.name,
-            "--namespace",
-            params.namespace,
-        ]);
-        const response = {
-            status: "uninstalled",
-            message: `Successfully uninstalled ${params.name}`,
-        };
+        executeCommand("helm", ["uninstall", params.name, "--namespace", params.namespace]);
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(response, null, 2),
-                },
-            ],
+                    text: JSON.stringify({
+                        status: "uninstalled",
+                        message: `Helm chart '${params.name}' uninstalled successfully from namespace '${params.namespace}'`
+                    })
+                }
+            ]
         };
     }
     catch (error) {
-        throw new Error(`Failed to uninstall Helm chart: ${error.message}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "failed",
+                        error: `Failed to uninstall Helm chart: ${error.message}`
+                    })
+                }
+            ]
+        };
     }
 }

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

@@ -14,20 +14,25 @@ export declare const kubectlApplySchema: {
                 readonly description: "Path to a YAML file to apply (optional - use either manifest or filename)";
             };
             readonly namespace: {
-                readonly type: "string";
-                readonly description: "Namespace to apply the resource to (optional)";
-                readonly default: "default";
+                type: "string";
+                description: string;
+                default: string;
             };
             readonly dryRun: {
-                readonly type: "boolean";
-                readonly description: "If true, only validate the resource, don't apply it";
-                readonly default: false;
+                type: "boolean";
+                description: string;
+                default: boolean;
             };
             readonly force: {
                 readonly type: "boolean";
                 readonly description: "If true, immediately remove resources from API and bypass graceful deletion";
                 readonly default: false;
             };
+            readonly context: {
+                type: "string";
+                description: string;
+                default: string;
+            };
         };
         readonly required: readonly [];
     };
@@ -38,6 +43,7 @@ export declare function kubectlApply(k8sManager: KubernetesManager, input: {
     namespace?: string;
     dryRun?: boolean;
     force?: boolean;
+    context?: string;
 }): Promise<{
     content: {
         type: string;

package/dist/tools/kubectl-apply.js

@@ -4,6 +4,7 @@ import * as fs from "fs";
 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";
 export const kubectlApplySchema = {
     name: "kubectl_apply",
     description: "Apply a Kubernetes YAML manifest from a string or file",
@@ -18,21 +19,14 @@ export const kubectlApplySchema = {
                 type: "string",
                 description: "Path to a YAML file to apply (optional - use either manifest or filename)",
             },
-            namespace: {
-                type: "string",
-                description: "Namespace to apply the resource to (optional)",
-                default: "default",
-            },
-            dryRun: {
-                type: "boolean",
-                description: "If true, only validate the resource, don't apply it",
-                default: false,
-            },
+            namespace: namespaceParameter,
+            dryRun: dryRunParameter,
             force: {
                 type: "boolean",
                 description: "If true, immediately remove resources from API and bypass graceful deletion",
                 default: false,
             },
+            context: contextParameter,
         },
         required: [],
     },
@@ -45,6 +39,7 @@ export async function kubectlApply(k8sManager, input) {
         const namespace = input.namespace || "default";
         const dryRun = input.dryRun || false;
         const force = input.force || false;
+        const context = input.context || "";
         let command = "kubectl";
         let args = ["apply"];
         let tempFile = null;
@@ -69,6 +64,10 @@ export async function kubectlApply(k8sManager, input) {
         if (force) {
             args.push("--force");
         }
+        // Add context if provided
+        if (context) {
+            args.push("--context", context);
+        }
         // Execute the command
         try {
             const result = execFileSync(command, args, {

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

@@ -6,9 +6,9 @@ export declare const kubectlCreateSchema: {
         readonly type: "object";
         readonly properties: {
             readonly dryRun: {
-                readonly type: "boolean";
-                readonly description: "If true, only validate the resource, don't actually create it";
-                readonly default: false;
+                type: "boolean";
+                description: string;
+                default: boolean;
             };
             readonly output: {
                 readonly type: "string";
@@ -38,9 +38,9 @@ export declare const kubectlCreateSchema: {
                 readonly description: "Name of the resource to create";
             };
             readonly namespace: {
-                readonly type: "string";
-                readonly description: "Namespace to create the resource in";
-                readonly default: "default";
+                type: "string";
+                description: string;
+                default: string;
             };
             readonly fromLiteral: {
                 readonly type: "array";
@@ -116,6 +116,11 @@ export declare const kubectlCreateSchema: {
                 };
                 readonly description: "Annotations to apply to the resource (e.g. [\"key1=value1\", \"key2=value2\"])";
             };
+            readonly context: {
+                type: "string";
+                description: string;
+                default: string;
+            };
         };
         readonly required: readonly [];
     };
@@ -142,6 +147,7 @@ export declare function kubectlCreate(k8sManager: KubernetesManager, input: {
     annotations?: string[];
     schedule?: string;
     suspend?: boolean;
+    context?: string;
 }): Promise<{
     content: {
         type: string;