mcp-server-kubernetes 2.7.0 → 2.9.0

package/dist/tools/kubectl-rollout.js

@@ -1,6 +1,7 @@
 import { execFileSync } from "child_process";
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 import { getSpawnMaxBuffer } from "../config/max-buffer.js";
+import { contextParameter, namespaceParameter } from "../models/common-parameters.js";
 export const kubectlRolloutSchema = {
     name: "kubectl_rollout",
     description: "Manage the rollout of a resource (e.g., deployment, daemonset, statefulset)",
@@ -23,11 +24,7 @@ export const kubectlRolloutSchema = {
                 type: "string",
                 description: "Name of the resource",
             },
-            namespace: {
-                type: "string",
-                description: "Namespace of the resource",
-                default: "default",
-            },
+            namespace: namespaceParameter,
             revision: {
                 type: "number",
                 description: "Revision to rollback to (for undo subcommand)",
@@ -45,6 +42,7 @@ export const kubectlRolloutSchema = {
                 description: "Watch the rollout status in real-time until completion",
                 default: false,
             },
+            context: contextParameter,
         },
         required: ["subCommand", "resourceType", "name", "namespace"],
     },
@@ -53,6 +51,7 @@ export async function kubectlRollout(k8sManager, input) {
     try {
         const namespace = input.namespace || "default";
         const watch = input.watch || false;
+        const context = input.context || "";
         const command = "kubectl";
         const args = [
             "rollout",
@@ -73,6 +72,10 @@ export async function kubectlRollout(k8sManager, input) {
         if (input.timeout) {
             args.push(`--timeout=${input.timeout}`);
         }
+        // Add context if provided
+        if (context) {
+            args.push("--context", context);
+        }
         // Execute the command
         try {
             // For status command with watch flag, we need to handle it differently

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

@@ -10,7 +10,7 @@ export declare const kubectlScaleSchema: {
                 description: string;
             };
             namespace: {
-                type: string;
+                type: "string";
                 description: string;
                 default: string;
             };
@@ -23,6 +23,11 @@ export declare const kubectlScaleSchema: {
                 description: string;
                 default: string;
             };
+            context: {
+                type: "string";
+                description: string;
+                default: string;
+            };
         };
         required: string[];
     };
@@ -32,6 +37,7 @@ export declare function kubectlScale(k8sManager: KubernetesManager, input: {
     namespace?: string;
     replicas: number;
     resourceType?: string;
+    context?: string;
 }): Promise<{
     content: {
         success: boolean;

package/dist/tools/kubectl-scale.js

@@ -1,6 +1,7 @@
 import { execFileSync } from "child_process";
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 import { getSpawnMaxBuffer } from "../config/max-buffer.js";
+import { contextParameter, namespaceParameter } from "../models/common-parameters.js";
 export const kubectlScaleSchema = {
     name: "kubectl_scale",
     description: "Scale a Kubernetes deployment",
@@ -11,11 +12,7 @@ export const kubectlScaleSchema = {
                 type: "string",
                 description: "Name of the deployment to scale",
             },
-            namespace: {
-                type: "string",
-                description: "Namespace of the deployment",
-                default: "default",
-            },
+            namespace: namespaceParameter,
             replicas: {
                 type: "number",
                 description: "Number of replicas to scale to",
@@ -25,6 +22,7 @@ export const kubectlScaleSchema = {
                 description: "Resource type to scale (deployment, replicaset, statefulset)",
                 default: "deployment",
             },
+            context: contextParameter,
         },
         required: ["name", "replicas"],
     },
@@ -33,6 +31,7 @@ export async function kubectlScale(k8sManager, input) {
     try {
         const namespace = input.namespace || "default";
         const resourceType = input.resourceType || "deployment";
+        const context = input.context || "";
         const command = "kubectl";
         const args = [
             "scale",
@@ -41,6 +40,10 @@ export async function kubectlScale(k8sManager, input) {
             `--replicas=${input.replicas}`,
             `--namespace=${namespace}`,
         ];
+        // Add context if provided
+        if (context) {
+            args.push("--context", context);
+        }
         // Execute the command
         try {
             const result = execFileSync(command, args, {

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 {};

package/dist/tools/node-management.js

@@ -0,0 +1,291 @@
+/**
+ * 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.
+ */
+import { execFileSync } from "child_process";
+import { getSpawnMaxBuffer } from "../config/max-buffer.js";
+/**
+ * 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 const nodeManagementSchema = {
+    name: "node_management",
+    description: "Manage Kubernetes nodes with cordon, drain, and uncordon operations",
+    inputSchema: {
+        type: "object",
+        properties: {
+            operation: {
+                type: "string",
+                description: "Node operation to perform",
+                enum: ["cordon", "drain", "uncordon"],
+            },
+            nodeName: {
+                type: "string",
+                description: "Name of the node to operate on (required for cordon, drain, uncordon)",
+            },
+            force: {
+                type: "boolean",
+                description: "Force the operation even if there are pods not managed by a ReplicationController, ReplicaSet, Job, DaemonSet or StatefulSet (for drain operation)",
+                default: false,
+            },
+            gracePeriod: {
+                type: "number",
+                description: "Period of time in seconds given to each pod to terminate gracefully (for drain operation). If set to -1, uses the kubectl default grace period.",
+                default: -1,
+            },
+            deleteLocalData: {
+                type: "boolean",
+                description: "Delete local data even if emptyDir volumes are used (for drain operation)",
+                default: false,
+            },
+            ignoreDaemonsets: {
+                type: "boolean",
+                description: "Ignore DaemonSet-managed pods (for drain operation)",
+                default: true,
+            },
+            timeout: {
+                type: "string",
+                description: "The length of time to wait before giving up (for drain operation, e.g., '5m', '1h')",
+                default: "0",
+            },
+            dryRun: {
+                type: "boolean",
+                description: "Show what would be done without actually doing it (for drain operation)",
+                default: false,
+            },
+            confirmDrain: {
+                type: "boolean",
+                description: "Explicit confirmation to drain the node (required for drain operation)",
+                default: false,
+            },
+        },
+        required: ["operation"],
+    },
+};
+/**
+ * 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 {
+        return execFileSync(command, args, {
+            encoding: "utf8",
+            timeout: 300000, // 5 minutes timeout for node operations
+            maxBuffer: getSpawnMaxBuffer(),
+            env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG },
+        });
+    }
+    catch (error) {
+        throw new Error(`${command} command failed: ${error.message}`);
+    }
+};
+/**
+ * Get the status of a specific node.
+ * @param nodeName - Name of the node to get status for
+ * @returns Node status as JSON object
+ * @throws Error if node status retrieval fails
+ */
+const getNodeStatus = (nodeName) => {
+    try {
+        const output = executeCommand("kubectl", ["get", "node", nodeName, "-o", "json"]);
+        return JSON.parse(output);
+    }
+    catch (error) {
+        throw new Error(`Failed to get node status: ${error.message}`);
+    }
+};
+/**
+ * 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 async function nodeManagement(params) {
+    const { operation, nodeName, force = false, gracePeriod = -1, deleteLocalData = false, ignoreDaemonsets = true, timeout = "0", dryRun = false, confirmDrain = false } = params;
+    try {
+        switch (operation) {
+            case "cordon":
+                return handleCordonNode(nodeName);
+            case "uncordon":
+                return handleUncordonNode(nodeName);
+            case "drain":
+                return handleDrainNode({
+                    nodeName: nodeName,
+                    force,
+                    gracePeriod,
+                    deleteLocalData,
+                    ignoreDaemonsets,
+                    timeout,
+                    dryRun,
+                    confirmDrain
+                });
+            default:
+                throw new Error(`Unknown operation: ${operation}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Node management operation failed: ${error.message}`
+                }
+            ]
+        };
+    }
+}
+/**
+ * Handle the cordon node operation.
+ * @param nodeName - Name of the node to cordon
+ * @returns Promise with cordon operation results
+ */
+async function handleCordonNode(nodeName) {
+    try {
+        // Check if node exists and get current status
+        const nodeStatus = getNodeStatus(nodeName);
+        const isSchedulable = !nodeStatus.spec.unschedulable;
+        if (!isSchedulable) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Node '${nodeName}' is already cordoned (unschedulable)`
+                    }
+                ]
+            };
+        }
+        // Cordon the node
+        executeCommand("kubectl", ["cordon", nodeName]);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully cordoned node '${nodeName}'. The node is now unschedulable.`
+                }
+            ]
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to cordon node: ${error.message}`);
+    }
+}
+/**
+ * Handle the uncordon node operation.
+ * @param nodeName - Name of the node to uncordon
+ * @returns Promise with uncordon operation results
+ */
+async function handleUncordonNode(nodeName) {
+    try {
+        // Check if node exists and get current status
+        const nodeStatus = getNodeStatus(nodeName);
+        const isSchedulable = !nodeStatus.spec.unschedulable;
+        if (isSchedulable) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Node '${nodeName}' is already uncordoned (schedulable)`
+                    }
+                ]
+            };
+        }
+        // Uncordon the node
+        executeCommand("kubectl", ["uncordon", nodeName]);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully uncordoned node '${nodeName}'. The node is now schedulable.`
+                }
+            ]
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to uncordon node: ${error.message}`);
+    }
+}
+/**
+ * Handle the drain node operation with safety checks and confirmation.
+ * @param params - Drain operation parameters
+ * @returns Promise with drain operation results
+ */
+async function handleDrainNode(params) {
+    const { nodeName, force, gracePeriod, deleteLocalData, ignoreDaemonsets, timeout, dryRun, confirmDrain } = params;
+    try {
+        // Check if node exists and get current status
+        const nodeStatus = getNodeStatus(nodeName);
+        const isSchedulable = !nodeStatus.spec.unschedulable;
+        if (!isSchedulable) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Node '${nodeName}' is already cordoned (unschedulable). Drain operation may not be necessary.`
+                    }
+                ]
+            };
+        }
+        // Check for confirmation if not in dry run mode
+        if (!dryRun && !confirmDrain) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Drain operation requires explicit confirmation. Set confirmDrain=true to proceed with draining node '${nodeName}'.`
+                    }
+                ]
+            };
+        }
+        // Build drain command arguments
+        const drainArgs = ["drain", nodeName];
+        if (force)
+            drainArgs.push("--force");
+        if (gracePeriod >= 0)
+            drainArgs.push("--grace-period", gracePeriod.toString());
+        if (deleteLocalData)
+            drainArgs.push("--delete-local-data");
+        if (ignoreDaemonsets)
+            drainArgs.push("--ignore-daemonsets");
+        if (timeout !== "0")
+            drainArgs.push("--timeout", timeout);
+        if (dryRun)
+            drainArgs.push("--dry-run=client");
+        // Execute drain command
+        const drainOutput = executeCommand("kubectl", drainArgs);
+        if (dryRun) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Dry run drain operation for node '${nodeName}':\n\n${drainOutput}\n\nTo perform the actual drain, set dryRun=false and confirmDrain=true.`
+                    }
+                ]
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully drained node '${nodeName}'.\n\n${drainOutput}`
+                }
+            ]
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to drain node: ${error.message}`);
+    }
+}

package/dist/utils/sse.js

@@ -21,6 +21,27 @@ export function startSSEServer(server) {
                 .send("Not found. Must pass valid sessionId as query param.");
         }
     });
+    app.get("/health", async (req, res) => {
+        res.json({ status: "ok" });
+    });
+    app.get("/ready", async (req, res) => {
+        try {
+            // We can add more checks if required
+            // For now, we'll consider the server ready if it can respond to this request
+            res.json({
+                status: "ready",
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            console.error("Readiness check failed:", error);
+            res.status(503).json({
+                status: "not ready",
+                reason: "Server initialization incomplete",
+                timestamp: new Date().toISOString()
+            });
+        }
+    });
     let port = 3000;
     try {
         port = parseInt(process.env.PORT || "3000", 10);

package/dist/utils/streamable-http.js

@@ -64,6 +64,27 @@ export function startStreamableHTTPServer(server) {
             id: null,
         }));
     });
+    app.get("/health", async (req, res) => {
+        res.json({ status: "ok" });
+    });
+    app.get("/ready", async (req, res) => {
+        try {
+            // We can add more checks if required
+            // For now, we'll consider the server ready if it can respond to this request
+            res.json({
+                status: "ready",
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            console.error("Readiness check failed:", error);
+            res.status(503).json({
+                status: "not ready",
+                reason: "Server initialization incomplete",
+                timestamp: new Date().toISOString()
+            });
+        }
+    });
     let port = 3000;
     try {
         port = parseInt(process.env.PORT || "3000", 10);

package/package.json

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