mcp-server-kubernetes 2.8.0 → 2.9.0

package/dist/tools/helm-operations.js

@@ -1,77 +1,122 @@
+/**
+ * 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",
+                description: "Helm repository URL (optional if using local chart path)",
             },
-            namespace: namespaceParameter,
-            context: contextParameter,
             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",
+                description: "Helm repository URL (optional if using local chart path)",
             },
-            namespace: namespaceParameter,
-            context: contextParameter,
             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",
+                description: "Name of the Helm release to uninstall",
             },
             namespace: namespaceParameter,
             context: contextParameter,
@@ -79,144 +124,295 @@ export const uninstallHelmChartSchema = {
         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`);
         }
-        let command = "helm";
-        let args = [
-            "install",
+        // 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);
+        }
+        // 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/node-management.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Tool: node_management
+ * Manage Kubernetes nodes with cordon, drain, and uncordon operations.
+ * Provides safety features for node operations and implements proper error handling
+ * and confirmation requirements for destructive operations.
+ * Note: Use kubectl_get with resourceType="nodes" to list nodes.
+ */
+/**
+ * Schema for node_management tool.
+ * - operation: Node operation to perform (cordon, drain, uncordon)
+ * - nodeName: Name of the node to operate on (required for cordon, drain, uncordon)
+ * - force: Force the operation even if there are unmanaged pods (for drain)
+ * - gracePeriod: Grace period for pod termination (for drain)
+ * - deleteLocalData: Delete local data even if emptyDir volumes are used (for drain)
+ * - ignoreDaemonsets: Ignore DaemonSet-managed pods (for drain)
+ * - timeout: Timeout for drain operation
+ * - dryRun: Show what would be done without actually doing it (for drain)
+ * - confirmDrain: Explicit confirmation to drain the node (required for drain)
+ */
+export declare const nodeManagementSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            operation: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            nodeName: {
+                type: string;
+                description: string;
+            };
+            force: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            gracePeriod: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            deleteLocalData: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            ignoreDaemonsets: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            timeout: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            dryRun: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            confirmDrain: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+/**
+ * Interface for node_management tool parameters.
+ */
+interface NodeManagementParams {
+    operation: "cordon" | "drain" | "uncordon";
+    nodeName?: string;
+    force?: boolean;
+    gracePeriod?: number;
+    deleteLocalData?: boolean;
+    ignoreDaemonsets?: boolean;
+    timeout?: string;
+    dryRun?: boolean;
+    confirmDrain?: boolean;
+}
+/**
+ * Main node_management function that handles all node operations.
+ * Implements safety features and proper error handling for node management tasks.
+ * @param params - Node management parameters
+ * @returns Promise with operation results
+ */
+export declare function nodeManagement(params: NodeManagementParams): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export {};