mcp-server-kubernetes 1.3.2 → 1.5.0

package/dist/tools/update_service.d.ts

@@ -0,0 +1,72 @@
+import { KubernetesManager } from "../types.js";
+export declare const updateServiceSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        required: string[];
+        properties: {
+            name: {
+                type: string;
+            };
+            namespace: {
+                type: string;
+                default: string;
+            };
+            type: {
+                type: string;
+                enum: string[];
+            };
+            selector: {
+                type: string;
+                additionalProperties: {
+                    type: string;
+                };
+            };
+            ports: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        port: {
+                            type: string;
+                        };
+                        targetPort: {
+                            type: string;
+                        };
+                        protocol: {
+                            type: string;
+                            enum: string[];
+                            default: string;
+                        };
+                        name: {
+                            type: string;
+                        };
+                        nodePort: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+    };
+};
+export declare function updateService(k8sManager: KubernetesManager, params: {
+    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/update_service.js

@@ -0,0 +1,125 @@
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const updateServiceSchema = {
+    name: "update_service",
+    description: "Update an existing kubernetes service in cluster",
+    inputSchema: {
+        type: "object",
+        required: ["name", "namespace"],
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string", default: "default" },
+            type: {
+                type: "string",
+                enum: ["ClusterIP", "NodePort", "LoadBalancer"],
+            },
+            selector: {
+                type: "object",
+                additionalProperties: { type: "string" },
+            },
+            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"]
+                }
+            }
+        },
+    },
+};
+export async function updateService(k8sManager, params) {
+    // Get existing service
+    const { body: existingService } = await k8sManager
+        .getCoreApi()
+        .readNamespacedService(params.name, params.namespace)
+        .catch((error) => {
+        console.error("Service read error:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        if (error.response?.statusCode === 404) {
+            throw new McpError(ErrorCode.InvalidRequest, `Service '${params.name}' not found in namespace '${params.namespace}'`);
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to retrieve service: ${error.response?.body?.message || error.message}`);
+    });
+    // Process ports if provided
+    let servicePorts;
+    if (params.ports) {
+        servicePorts = params.ports.map((portConfig, index) => {
+            const existingPort = existingService.spec?.ports?.[index];
+            const name = portConfig.name || (existingPort?.name || `port-${index}`);
+            return {
+                port: portConfig.port,
+                targetPort: portConfig.targetPort !== undefined
+                    ? portConfig.targetPort
+                    : portConfig.port,
+                protocol: portConfig.protocol || "TCP",
+                name: name,
+                ...(existingService.spec?.type === "NodePort" || params.type === "NodePort" ?
+                    { nodePort: portConfig.nodePort !== undefined ? portConfig.nodePort : existingPort?.nodePort } : {})
+            };
+        });
+    }
+    const updatedService = {
+        ...existingService,
+        spec: {
+            ...existingService.spec,
+            type: params.type || existingService.spec.type,
+            selector: params.selector || existingService.spec.selector,
+            ports: servicePorts || existingService.spec.ports,
+            clusterIP: existingService.spec.clusterIP,
+        },
+    };
+    try {
+        const { body } = await k8sManager
+            .getCoreApi()
+            .replaceNamespacedService(params.name, params.namespace, updatedService);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        message: "Service updated successfully",
+                        service: {
+                            name: body.metadata?.name,
+                            namespace: body.metadata?.namespace,
+                            type: body.spec?.type,
+                            clusterIP: body.spec?.clusterIP,
+                            ports: body.spec?.ports,
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Service update error:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        if (error instanceof McpError)
+            throw error;
+        // Handle specific Kubernetes API errors
+        if (error.response?.body?.message) {
+            if (error.response.body.message.includes("field is immutable")) {
+                throw new McpError(ErrorCode.InvalidRequest, `Update failed: Attempted to modify immutable field. ${error.response.body.message}`);
+            }
+            if (error.response.statusCode === 422) {
+                throw new McpError(ErrorCode.InvalidRequest, `Invalid service configuration: ${error.response.body.message}`);
+            }
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to update service: ${error.response?.body?.message || error.message}`);
+    }
+}

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.2",
+  "version": "1.5.0",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",