mcp-server-kubernetes 1.3.1 → 1.4.0

package/README.md

@@ -70,6 +70,7 @@ npx mcp-chat --config "%APPDATA%\Claude\claude_desktop_config.json"
 - [x] Create, describe, delete a pod
 - [x] List all namespaces, create a namespace
 - [x] Create custom pod & deployment configs, update deployment replicas
+- [x] Create services
 - [x] Get logs from a pod for debugging (supports pods, deployments, jobs, and label selectors)
 - [x] Support Helm v3 for installing charts
   - Install charts with custom values
@@ -82,6 +83,7 @@ npx mcp-chat --config "%APPDATA%\Claude\claude_desktop_config.json"
 - [x] Get Kubernetes events from the cluster
 - [x] Port forward to a pod or service
 - [x] Create, list, and decribe cronjobs
+- [x] Non-destructive mode for read and create/update-only access to clusters
 
 ## Local Development
 
@@ -143,7 +145,9 @@ See the [CONTRIBUTING.md](CONTRIBUTING.md) file for details.
 
 ## Advanced
 
-For more advanced information like using SSE transport, see the [ADVANCED_README.md](ADVANCED_README.md).
+### Additional Advanced Features
+
+For more advanced information like using SSE transport, Non-destructive mode with `ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS`, see the [ADVANCED_README.md](ADVANCED_README.md).
 
 ## Architecture
 

package/dist/index.js

@@ -33,49 +33,74 @@ import { deleteDeployment, deleteDeploymentSchema } from "./tools/delete_deploym
 import { createDeployment } from "./tools/create_deployment.js";
 import { scaleDeployment, scaleDeploymentSchema } from "./tools/scale_deployment.js";
 import { describeDeployment, describeDeploymentSchema, } from "./tools/describe_deployment.js";
+import { updateDeployment, updateDeploymentSchema } from "./tools/update_deployment.js";
 import { createConfigMap, CreateConfigMapSchema } from "./tools/create_configmap.js";
+import { createService, createServiceSchema } from "./tools/create_service.js";
+import { listContexts, listContextsSchema } from "./tools/list_contexts.js";
+import { getCurrentContext, getCurrentContextSchema } from "./tools/get_current_context.js";
+import { setCurrentContext, setCurrentContextSchema } from "./tools/set_current_context.js";
+// Check if non-destructive tools only mode is enabled
+const nonDestructiveTools = process.env.ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS === 'true';
 const k8sManager = new KubernetesManager();
 const server = new Server({
     name: serverConfig.name,
     version: serverConfig.version,
 }, serverConfig);
+// Define destructive tools (delete and uninstall operations)
+const destructiveTools = [
+    deletePodSchema,
+    deleteDeploymentSchema,
+    deleteNamespaceSchema,
+    uninstallHelmChartSchema,
+    DeleteCronJobSchema,
+    cleanupSchema, // Cleanup is also destructive as it deletes resources
+];
 // Tools handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            cleanupSchema,
-            createDeploymentSchema,
-            createNamespaceSchema,
-            createPodSchema,
-            createCronJobSchema,
-            deletePodSchema,
-            deleteDeploymentSchema,
-            deleteNamespaceSchema,
-            describeCronJobSchema,
-            describePodSchema,
-            describeDeploymentSchema,
-            explainResourceSchema,
-            getEventsSchema,
-            getJobLogsSchema,
-            getLogsSchema,
-            installHelmChartSchema,
-            listApiResourcesSchema,
-            listCronJobsSchema,
-            listDeploymentsSchema,
-            listJobsSchema,
-            listNamespacesSchema,
-            listNodesSchema,
-            listPodsSchema,
-            listServicesSchema,
-            uninstallHelmChartSchema,
-            upgradeHelmChartSchema,
-            PortForwardSchema,
-            StopPortForwardSchema,
-            scaleDeploymentSchema,
-            DeleteCronJobSchema,
-            CreateConfigMapSchema,
-        ],
-    };
+    // Get all available tools
+    const allTools = [
+        cleanupSchema,
+        createDeploymentSchema,
+        createNamespaceSchema,
+        createPodSchema,
+        createCronJobSchema,
+        createServiceSchema,
+        deletePodSchema,
+        deleteDeploymentSchema,
+        deleteNamespaceSchema,
+        describeCronJobSchema,
+        describePodSchema,
+        describeDeploymentSchema,
+        explainResourceSchema,
+        getEventsSchema,
+        getJobLogsSchema,
+        getLogsSchema,
+        installHelmChartSchema,
+        listApiResourcesSchema,
+        listCronJobsSchema,
+        listContextsSchema,
+        getCurrentContextSchema,
+        setCurrentContextSchema,
+        listDeploymentsSchema,
+        listJobsSchema,
+        listNamespacesSchema,
+        listNodesSchema,
+        listPodsSchema,
+        listServicesSchema,
+        uninstallHelmChartSchema,
+        updateDeploymentSchema,
+        upgradeHelmChartSchema,
+        PortForwardSchema,
+        StopPortForwardSchema,
+        scaleDeploymentSchema,
+        DeleteCronJobSchema,
+        CreateConfigMapSchema,
+    ];
+    // Filter out destructive tools if ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS is set to 'true'
+    const tools = nonDestructiveTools
+        ? allTools.filter(tool => !destructiveTools.some(dt => dt.name === tool.name))
+        : allTools;
+    return { tools };
 });
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
@@ -158,6 +183,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "list_cronjobs": {
                 return await listCronJobs(k8sManager, input);
             }
+            case "list_contexts": {
+                return await listContexts(k8sManager, input);
+            }
+            case "get_current_context": {
+                return await getCurrentContext(k8sManager, input);
+            }
+            case "set_current_context": {
+                return await setCurrentContext(k8sManager, input);
+            }
             case "describe_cronjob": {
                 return await describeCronJob(k8sManager, input);
             }
@@ -188,6 +222,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "create_deployment": {
                 return await createDeployment(k8sManager, input);
             }
+            case "update_deployment": {
+                return await updateDeployment(k8sManager, input);
+            }
             case "describe_deployment": {
                 return await describeDeployment(k8sManager, input);
             }
@@ -197,6 +234,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "create_configmap": {
                 return await createConfigMap(k8sManager, input);
             }
+            case "create_service": {
+                return await createService(k8sManager, input);
+            }
             default:
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
         }

package/dist/models/response-schemas.d.ts

@@ -505,3 +505,69 @@ export declare const CreateConfigMapResponseSchema: z.ZodObject<{
         success: boolean;
     }[];
 }>;
+export declare const ListContextsResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const GetCurrentContextResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const SetCurrentContextResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/models/response-schemas.js

@@ -85,3 +85,12 @@ export const CreateConfigMapResponseSchema = z.object({
         message: z.string(),
     })),
 });
+export const ListContextsResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const GetCurrentContextResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const SetCurrentContextResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});

package/dist/tools/create_service.d.ts

@@ -0,0 +1,74 @@
+import { KubernetesManager } from "../types.js";
+export declare const createServiceSchema: {
+    readonly name: "create_service";
+    readonly description: "Create a new Kubernetes service";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly namespace: {
+                readonly type: "string";
+                readonly default: "default";
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["ClusterIP", "NodePort", "LoadBalancer"];
+                readonly default: "ClusterIP";
+            };
+            readonly selector: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "string";
+                };
+                readonly default: {};
+            };
+            readonly ports: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly port: {
+                            readonly type: "number";
+                        };
+                        readonly targetPort: {
+                            readonly type: "number";
+                        };
+                        readonly protocol: {
+                            readonly type: "string";
+                            readonly enum: readonly ["TCP", "UDP"];
+                            readonly default: "TCP";
+                        };
+                        readonly name: {
+                            readonly type: "string";
+                        };
+                        readonly nodePort: {
+                            readonly type: "number";
+                        };
+                    };
+                    readonly required: readonly ["port"];
+                };
+            };
+        };
+        readonly required: readonly ["name", "ports"];
+    };
+};
+export declare function createService(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace?: string;
+    type?: "ClusterIP" | "NodePort" | "LoadBalancer";
+    selector?: Record<string, string>;
+    ports: Array<{
+        port: number;
+        targetPort?: number;
+        protocol?: string;
+        name?: string;
+        nodePort?: number;
+    }>;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/create_service.js

@@ -0,0 +1,102 @@
+export const createServiceSchema = {
+    name: "create_service",
+    description: "Create a new Kubernetes service",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string", default: "default" },
+            type: {
+                type: "string",
+                enum: ["ClusterIP", "NodePort", "LoadBalancer"],
+                default: "ClusterIP"
+            },
+            selector: {
+                type: "object",
+                additionalProperties: { type: "string" },
+                default: {}
+            },
+            ports: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        port: { type: "number" },
+                        targetPort: { type: "number" },
+                        protocol: {
+                            type: "string",
+                            enum: ["TCP", "UDP"],
+                            default: "TCP"
+                        },
+                        name: { type: "string" },
+                        nodePort: { type: "number" }
+                    },
+                    required: ["port"]
+                }
+            }
+        },
+        required: ["name", "ports"],
+    },
+};
+export async function createService(k8sManager, input) {
+    const namespace = input.namespace || "default";
+    const serviceType = input.type || "ClusterIP";
+    // Convert ports to k8s.V1ServicePort format
+    const servicePorts = input.ports.map((portConfig, index) => {
+        return {
+            port: portConfig.port,
+            targetPort: portConfig.targetPort !== undefined ? portConfig.targetPort : portConfig.port,
+            protocol: portConfig.protocol || "TCP",
+            name: portConfig.name || `port-${index}`,
+            ...(serviceType === "NodePort" && portConfig.nodePort ? { nodePort: portConfig.nodePort } : {})
+        };
+    });
+    // Default selector
+    const selector = input.selector || { app: input.name };
+    const service = {
+        apiVersion: "v1",
+        kind: "Service",
+        metadata: {
+            name: input.name,
+            namespace: namespace,
+            labels: {
+                "mcp-managed": "true",
+                app: input.name,
+            },
+        },
+        spec: {
+            type: serviceType,
+            selector: selector,
+            ports: servicePorts
+        }
+    };
+    try {
+        const response = await k8sManager
+            .getCoreApi()
+            .createNamespacedService(namespace, service);
+        k8sManager.trackResource("Service", input.name, namespace);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        serviceName: response.body.metadata.name,
+                        namespace: response.body.metadata.namespace,
+                        type: response.body.spec.type,
+                        clusterIP: response.body.spec.clusterIP,
+                        ports: response.body.spec.ports,
+                        status: "created",
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Service creation error:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        throw error;
+    }
+}

package/dist/tools/get_current_context.d.ts

@@ -0,0 +1,23 @@
+import { KubernetesManager } from "../types.js";
+export declare const getCurrentContextSchema: {
+    readonly name: "get_current_context";
+    readonly description: "Get the current Kubernetes context";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly detailed: {
+                readonly type: "boolean";
+                readonly description: "Include detailed information about the current context";
+                readonly default: false;
+            };
+        };
+    };
+};
+export declare function getCurrentContext(k8sManager: KubernetesManager, input: {
+    detailed?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/get_current_context.js

@@ -0,0 +1,55 @@
+export const getCurrentContextSchema = {
+    name: "get_current_context",
+    description: "Get the current Kubernetes context",
+    inputSchema: {
+        type: "object",
+        properties: {
+            detailed: {
+                type: "boolean",
+                description: "Include detailed information about the current context",
+                default: false
+            }
+        }
+    },
+};
+export async function getCurrentContext(k8sManager, input) {
+    try {
+        // Get the KubeConfig from the KubernetesManager
+        const kc = k8sManager.getKubeConfig();
+        // Get the current context name
+        const currentContextName = kc.getCurrentContext();
+        // If detailed is true, get more information about the context
+        if (input.detailed) {
+            const contexts = kc.getContexts();
+            const currentContext = contexts.find(context => context.name === currentContextName);
+            if (!currentContext) {
+                throw new Error(`Current context '${currentContextName}' not found in available contexts`);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            name: currentContextName,
+                            cluster: currentContext.cluster,
+                            user: currentContext.user,
+                            namespace: currentContext.namespace || "default"
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        // Simple response with just the context name
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ currentContext: currentContextName }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to get current context: ${error.message}`);
+    }
+}

package/dist/tools/helm-operations.js

@@ -85,7 +85,11 @@ export const uninstallHelmChartSchema = {
 };
 const executeHelmCommand = (command) => {
     try {
-        return execSync(command, { encoding: "utf8" });
+        // Add a generous timeout of 60 seconds for Helm operations
+        return execSync(command, {
+            encoding: "utf8",
+            timeout: 60000 // 60 seconds timeout
+        });
     }
     catch (error) {
         throw new Error(`Helm command failed: ${error.message}`);

package/dist/tools/list_contexts.d.ts

@@ -0,0 +1,23 @@
+import { KubernetesManager } from "../types.js";
+export declare const listContextsSchema: {
+    readonly name: "list_contexts";
+    readonly description: "List all available Kubernetes contexts";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly showCurrent: {
+                readonly type: "boolean";
+                readonly description: "Show which context is currently active";
+                readonly default: true;
+            };
+        };
+    };
+};
+export declare function listContexts(k8sManager: KubernetesManager, input: {
+    showCurrent?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/list_contexts.js

@@ -0,0 +1,39 @@
+export const listContextsSchema = {
+    name: "list_contexts",
+    description: "List all available Kubernetes contexts",
+    inputSchema: {
+        type: "object",
+        properties: {
+            showCurrent: {
+                type: "boolean",
+                description: "Show which context is currently active",
+                default: true
+            }
+        }
+    },
+};
+export async function listContexts(k8sManager, input) {
+    try {
+        // Get the KubeConfig from the KubernetesManager
+        const kc = k8sManager.getKubeConfig();
+        const contexts = kc.getContexts();
+        const currentContext = input.showCurrent ? kc.getCurrentContext() : undefined;
+        const contextList = contexts.map(context => ({
+            name: context.name,
+            cluster: context.cluster,
+            user: context.user,
+            isCurrent: context.name === currentContext
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ contexts: contextList }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to list contexts: ${error.message}`);
+    }
+}

package/dist/tools/set_current_context.d.ts

@@ -0,0 +1,23 @@
+import { KubernetesManager } from "../types.js";
+export declare const setCurrentContextSchema: {
+    readonly name: "set_current_context";
+    readonly description: "Set the current Kubernetes context";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Name of the context to set as current";
+            };
+        };
+        readonly required: readonly ["name"];
+    };
+};
+export declare function setCurrentContext(k8sManager: KubernetesManager, input: {
+    name: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/set_current_context.js

@@ -0,0 +1,35 @@
+export const setCurrentContextSchema = {
+    name: "set_current_context",
+    description: "Set the current Kubernetes context",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Name of the context to set as current"
+            }
+        },
+        required: ["name"],
+    },
+};
+export async function setCurrentContext(k8sManager, input) {
+    try {
+        // Set the current context
+        k8sManager.setCurrentContext(input.name);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        message: `Current context set to '${input.name}'`,
+                        context: input.name
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to set current context: ${error.message}`);
+    }
+}

package/dist/tools/update_deployment.d.ts

@@ -0,0 +1,113 @@
+import { KubernetesManager } from "../types.js";
+import { CustomContainerConfigType } from "../config/container-templates.js";
+export declare const updateDeploymentSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        required: string[];
+        properties: {
+            name: {
+                type: string;
+            };
+            namespace: {
+                type: string;
+            };
+            template: {
+                type: string;
+                enum: ["ubuntu", "nginx", "busybox", "alpine", "custom"];
+            };
+            containerName: {
+                type: string;
+                description: string;
+            };
+            replicas: {
+                type: string;
+            };
+            customConfig: {
+                type: string;
+                properties: {
+                    image: {
+                        type: string;
+                    };
+                    command: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    args: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    ports: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                containerPort: {
+                                    type: string;
+                                };
+                                name: {
+                                    type: string;
+                                };
+                                protocol: {
+                                    type: string;
+                                };
+                            };
+                        };
+                    };
+                    resources: {
+                        type: string;
+                        properties: {
+                            limits: {
+                                type: string;
+                                additionalProperties: {
+                                    type: string;
+                                };
+                            };
+                            requests: {
+                                type: string;
+                                additionalProperties: {
+                                    type: string;
+                                };
+                            };
+                        };
+                    };
+                    env: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                name: {
+                                    type: string;
+                                };
+                                value: {
+                                    type: string;
+                                };
+                                valueFrom: {
+                                    type: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function updateDeployment(k8sManager: KubernetesManager, params: {
+    name: string;
+    namespace: string;
+    template: string;
+    containerName?: string;
+    replicas?: number;
+    customConfig?: CustomContainerConfigType;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/update_deployment.js

@@ -0,0 +1,155 @@
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { ContainerTemplate, containerTemplates, CustomContainerConfig, } from "../config/container-templates.js";
+export const updateDeploymentSchema = {
+    name: "update_deployment",
+    description: "Update an existing kubernetes deployment in cluster",
+    inputSchema: {
+        type: "object",
+        required: ["name", "namespace", "template"],
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string" },
+            template: {
+                type: "string",
+                enum: ContainerTemplate.options,
+            },
+            containerName: {
+                type: "string",
+                description: "Name of the container to update",
+            },
+            replicas: { type: "number" },
+            customConfig: {
+                type: "object",
+                properties: {
+                    image: { type: "string" },
+                    command: { type: "array", items: { type: "string" } },
+                    args: { type: "array", items: { type: "string" } },
+                    ports: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                containerPort: { type: "number" },
+                                name: { type: "string" },
+                                protocol: { type: "string" },
+                            },
+                        },
+                    },
+                    resources: {
+                        type: "object",
+                        properties: {
+                            limits: {
+                                type: "object",
+                                additionalProperties: { type: "string" },
+                            },
+                            requests: {
+                                type: "object",
+                                additionalProperties: { type: "string" },
+                            },
+                        },
+                    },
+                    env: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                name: { type: "string" },
+                                value: { type: "string" },
+                                valueFrom: { type: "object" },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+export async function updateDeployment(k8sManager, params) {
+    // Get existing deployment
+    const { body: existingDeployment } = await k8sManager
+        .getAppsApi()
+        .readNamespacedDeployment(params.name, params.namespace)
+        .catch((error) => {
+        console.error("Deployment read error:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        throw error;
+    });
+    // Find target container
+    const containers = existingDeployment.spec.template.spec.containers;
+    let targetContainerIndex = params.containerName
+        ? containers.findIndex(c => c.name === params.containerName)
+        : 0;
+    if (targetContainerIndex === -1) {
+        throw new McpError(ErrorCode.InvalidRequest, `Container '${params.containerName}' not found in deployment`);
+    }
+    // Prepare container config
+    const templateConfig = containerTemplates[params.template];
+    let containerConfig;
+    if (params.template === "custom") {
+        if (!params.customConfig) {
+            throw new McpError(ErrorCode.InvalidRequest, "Custom container configuration is required when using 'custom' template");
+        }
+        const validatedConfig = CustomContainerConfig.parse(params.customConfig);
+        containerConfig = {
+            ...containers[targetContainerIndex],
+            ...templateConfig,
+            image: validatedConfig.image,
+            command: validatedConfig.command,
+            args: validatedConfig.args,
+            ports: validatedConfig.ports,
+            resources: validatedConfig.resources,
+            env: validatedConfig.env,
+        };
+    }
+    else {
+        containerConfig = {
+            ...containers[targetContainerIndex],
+            ...templateConfig,
+        };
+    }
+    // Update deployment
+    const updatedContainers = [...containers];
+    updatedContainers[targetContainerIndex] = containerConfig;
+    const updatedDeployment = {
+        ...existingDeployment,
+        spec: {
+            ...existingDeployment.spec,
+            replicas: params.replicas ?? existingDeployment.spec.replicas,
+            template: {
+                ...existingDeployment.spec.template,
+                spec: {
+                    ...existingDeployment.spec.template.spec,
+                    containers: updatedContainers,
+                },
+            },
+        },
+    };
+    const { body } = await k8sManager
+        .getAppsApi()
+        .replaceNamespacedDeployment(params.name, params.namespace, updatedDeployment)
+        .catch((error) => {
+        if (error instanceof McpError)
+            throw error;
+        throw new McpError(ErrorCode.InternalError, `Failed to update deployment: ${error}`);
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    message: "Deployment updated successfully",
+                    deployment: {
+                        name: body.metadata?.name,
+                        namespace: body.metadata?.namespace,
+                        replicas: body.spec?.replicas,
+                        image: body.spec?.template.spec?.containers[targetContainerIndex].image,
+                        containerName: body.spec?.template.spec?.containers[targetContainerIndex].name,
+                    },
+                }, null, 2),
+            },
+        ],
+    };
+}

package/dist/utils/kubernetes-manager.d.ts

@@ -9,6 +9,12 @@ export declare class KubernetesManager {
     private k8sAppsApi;
     private k8sBatchApi;
     constructor();
+    /**
+     * Set the current context to the desired context name.
+     *
+     * @param contextName
+     */
+    setCurrentContext(contextName: string): void;
     cleanup(): Promise<void>;
     trackResource(kind: string, name: string, namespace: string): void;
     deleteResource(kind: string, name: string, namespace: string): Promise<void>;

package/dist/utils/kubernetes-manager.js

@@ -14,6 +14,25 @@ export class KubernetesManager {
         this.k8sAppsApi = this.kc.makeApiClient(k8s.AppsV1Api);
         this.k8sBatchApi = this.kc.makeApiClient(k8s.BatchV1Api);
     }
+    /**
+     * Set the current context to the desired context name.
+     *
+     * @param contextName
+     */
+    setCurrentContext(contextName) {
+        // Get all available contexts
+        const contexts = this.kc.getContexts();
+        const contextNames = contexts.map(context => context.name);
+        // Check if the requested context exists
+        if (!contextNames.includes(contextName)) {
+            throw new Error(`Context '${contextName}' not found. Available contexts: ${contextNames.join(', ')}`);
+        }
+        // Set the current context
+        this.kc.setCurrentContext(contextName);
+        this.k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
+        this.k8sAppsApi = this.kc.makeApiClient(k8s.AppsV1Api);
+        this.k8sBatchApi = this.kc.makeApiClient(k8s.BatchV1Api);
+    }
     async cleanup() {
         // Stop watches
         for (const watch of this.watches) {

package/package.json

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