mcp-server-kubernetes 1.3.2 → 1.5.0

package/dist/tools/describe_node.js

@@ -0,0 +1,84 @@
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const describeNodeSchema = {
+    name: "describe_node",
+    description: "Describe a Kubernetes node (read details like status, capacity, conditions, etc.)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+        },
+        required: ["name"],
+    },
+};
+export async function describeNode(k8sManager, input) {
+    try {
+        const { body } = await k8sManager.getCoreApi().readNode(input.name);
+        if (!body) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Node not found",
+                            status: "not_found",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        // Format the node details for better readability
+        const nodeDetails = {
+            kind: body.kind,
+            metadata: {
+                name: body.metadata?.name,
+                creationTimestamp: body.metadata?.creationTimestamp,
+                labels: body.metadata?.labels,
+                annotations: body.metadata?.annotations,
+            },
+            spec: {
+                podCIDR: body.spec?.podCIDR,
+                podCIDRs: body.spec?.podCIDRs,
+                taints: body.spec?.taints,
+                unschedulable: body.spec?.unschedulable,
+            },
+            status: {
+                capacity: body.status?.capacity,
+                allocatable: body.status?.allocatable,
+                conditions: body.status?.conditions,
+                nodeInfo: {
+                    architecture: body.status?.nodeInfo?.architecture,
+                    containerRuntimeVersion: body.status?.nodeInfo?.containerRuntimeVersion,
+                    kernelVersion: body.status?.nodeInfo?.kernelVersion,
+                    kubeletVersion: body.status?.nodeInfo?.kubeletVersion,
+                    operatingSystem: body.status?.nodeInfo?.operatingSystem,
+                    osImage: body.status?.nodeInfo?.osImage,
+                },
+                addresses: body.status?.addresses,
+            },
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(nodeDetails, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (error.response?.statusCode === 404) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Node not found",
+                            status: "not_found",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to describe node: ${error.response?.body?.message || error.message}`);
+    }
+}

package/dist/tools/describe_service.d.ts

@@ -0,0 +1,34 @@
+import { KubernetesManager } from "../types.js";
+export declare const describeServiceSchema: {
+    readonly name: "describe_service";
+    readonly description: "Describe a Kubernetes service (read details like status, ports, selectors, etc.)";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly namespace: {
+                readonly type: "string";
+                readonly default: "default";
+            };
+        };
+        readonly required: readonly ["name"];
+    };
+};
+export declare function describeService(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace?: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/tools/describe_service.js

@@ -0,0 +1,85 @@
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const describeServiceSchema = {
+    name: "describe_service",
+    description: "Describe a Kubernetes service (read details like status, ports, selectors, etc.)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string", default: "default" },
+        },
+        required: ["name"],
+    },
+};
+export async function describeService(k8sManager, input) {
+    const namespace = input.namespace || "default";
+    try {
+        const { body } = await k8sManager.getCoreApi().readNamespacedService(input.name, namespace);
+        if (!body) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Service not found",
+                            status: "not_found",
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Format service details for better readability
+        const serviceDetails = {
+            kind: body.kind,
+            metadata: {
+                name: body.metadata?.name,
+                namespace: body.metadata?.namespace,
+                creationTimestamp: body.metadata?.creationTimestamp,
+                labels: body.metadata?.labels,
+            },
+            spec: {
+                type: body.spec?.type,
+                selector: body.spec?.selector,
+                ports: body.spec?.ports?.map((port) => ({
+                    name: port.name,
+                    protocol: port.protocol,
+                    port: port.port,
+                    targetPort: port.targetPort,
+                    nodePort: port.nodePort,
+                })),
+                clusterIP: body.spec?.clusterIP,
+                externalIPs: body.spec?.externalIPs,
+                loadBalancerIP: body.spec?.loadBalancerIP,
+            },
+            status: {
+                loadBalancer: body.status?.loadBalancer,
+            },
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(serviceDetails, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (error.response?.statusCode === 404) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Service not found",
+                            status: "not_found",
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to describe service: ${error.response?.body?.message || error.message}`);
+    }
+}

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),
+            },
+        ],
+    };
+}