mcp-server-kubernetes 1.6.2 → 2.1.0

package/dist/tools/update_deployment.js

@@ -1,155 +0,0 @@
-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/tools/update_service.d.ts

@@ -1,72 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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}`);
-    }
-}