mcp-server-kubernetes 1.4.0 → 1.5.0

package/README.md

@@ -67,10 +67,11 @@ npx mcp-chat --config "%APPDATA%\Claude\claude_desktop_config.json"
 
 - [x] Connect to a Kubernetes cluster
 - [x] List all pods, services, deployments, nodes
+- [x] Describe nodes
 - [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] Create, describe, delete, update a service
 - [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
@@ -87,6 +88,8 @@ npx mcp-chat --config "%APPDATA%\Claude\claude_desktop_config.json"
 
 ## Local Development
 
+Make sure that you have [bun installed](https://bun.sh/docs/installation). Clone the repo & install dependencies:
+
 ```bash
 git clone https://github.com/Flux159/mcp-server-kubernetes.git
 cd mcp-server-kubernetes
@@ -136,7 +139,7 @@ npx @modelcontextprotocol/inspector node dist/index.js
 6. Local testing with [mcp-chat](https://github.com/Flux159/mcp-chat)
 
 ```bash
-npm run chat
+bun run chat
 ```
 
 ## Contributing

package/dist/index.js

@@ -6,9 +6,10 @@ import { listNodes, listNodesSchema } from "./tools/list_nodes.js";
 import { listServices, listServicesSchema } from "./tools/list_services.js";
 import { listDeployments, listDeploymentsSchema, } from "./tools/list_deployments.js";
 import { listCronJobs, listCronJobsSchema } from "./tools/list_cronjobs.js";
-import { describeCronJob, describeCronJobSchema } from "./tools/describe_cronjob.js";
+import { describeCronJob, describeCronJobSchema, } from "./tools/describe_cronjob.js";
 import { listJobs, listJobsSchema } from "./tools/list_jobs.js";
 import { getJobLogs, getJobLogsSchema } from "./tools/get_job_logs.js";
+import { describeNode, describeNodeSchema } from "./tools/describe_node.js";
 import { installHelmChart, installHelmChartSchema, upgradeHelmChart, upgradeHelmChartSchema, uninstallHelmChart, uninstallHelmChartSchema, } from "./tools/helm-operations.js";
 import { explainResource, explainResourceSchema, listApiResources, listApiResourcesSchema, } from "./tools/kubectl-operations.js";
 import { createNamespace, createNamespaceSchema, } from "./tools/create_namespace.js";
@@ -25,22 +26,25 @@ import { KubernetesManager } from "./types.js";
 import { serverConfig } from "./config/server-config.js";
 import { createDeploymentSchema } from "./config/deployment-config.js";
 import { listNamespacesSchema } from "./config/namespace-config.js";
-import { deleteNamespace, deleteNamespaceSchema } from "./tools/delete_namespace.js";
+import { deleteNamespace, deleteNamespaceSchema, } from "./tools/delete_namespace.js";
 import { cleanupSchema } from "./config/cleanup-config.js";
 import { startSSEServer } from "./utils/sse.js";
 import { startPortForward, PortForwardSchema, stopPortForward, StopPortForwardSchema, } from "./tools/port_forward.js";
-import { deleteDeployment, deleteDeploymentSchema } from "./tools/delete_deployment.js";
+import { deleteDeployment, deleteDeploymentSchema, } from "./tools/delete_deployment.js";
 import { createDeployment } from "./tools/create_deployment.js";
-import { scaleDeployment, scaleDeploymentSchema } from "./tools/scale_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 { updateDeployment, updateDeploymentSchema, } from "./tools/update_deployment.js";
+import { createConfigMap, CreateConfigMapSchema, } from "./tools/create_configmap.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";
+import { getCurrentContext, getCurrentContextSchema, } from "./tools/get_current_context.js";
+import { setCurrentContext, setCurrentContextSchema, } from "./tools/set_current_context.js";
+import { createService, createServiceSchema } from "./tools/create_service.js";
+import { describeService, describeServiceSchema, } from "./tools/describe_service.js";
+import { updateService, updateServiceSchema } from "./tools/update_service.js";
+import { deleteService, deleteServiceSchema } from "./tools/delete_service.js";
 // Check if non-destructive tools only mode is enabled
-const nonDestructiveTools = process.env.ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS === 'true';
+const nonDestructiveTools = process.env.ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS === "true";
 const k8sManager = new KubernetesManager();
 const server = new Server({
     name: serverConfig.name,
@@ -49,6 +53,7 @@ const server = new Server({
 // Define destructive tools (delete and uninstall operations)
 const destructiveTools = [
     deletePodSchema,
+    deleteServiceSchema,
     deleteDeploymentSchema,
     deleteNamespaceSchema,
     uninstallHelmChartSchema,
@@ -68,9 +73,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         deletePodSchema,
         deleteDeploymentSchema,
         deleteNamespaceSchema,
+        deleteServiceSchema,
         describeCronJobSchema,
         describePodSchema,
+        describeNodeSchema,
         describeDeploymentSchema,
+        describeServiceSchema,
         explainResourceSchema,
         getEventsSchema,
         getJobLogsSchema,
@@ -95,10 +103,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         scaleDeploymentSchema,
         DeleteCronJobSchema,
         CreateConfigMapSchema,
+        updateServiceSchema,
     ];
     // 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.filter((tool) => !destructiveTools.some((dt) => dt.name === tool.name))
         : allTools;
     return { tools };
 });
@@ -137,6 +146,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "describe_pod": {
                 return await describePod(k8sManager, input);
             }
+            case "describe_node": {
+                return await describeNode(k8sManager, input);
+            }
             case "explain_resource": {
                 return await explainResource(input);
             }
@@ -237,6 +249,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "create_service": {
                 return await createService(k8sManager, input);
             }
+            case "update_service": {
+                return await updateService(k8sManager, input);
+            }
+            case "delete_service": {
+                return await deleteService(k8sManager, input);
+            }
+            case "describe_service": {
+                return await describeService(k8sManager, input);
+            }
             default:
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
         }

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

@@ -571,3 +571,25 @@ export declare const SetCurrentContextResponseSchema: z.ZodObject<{
         text: string;
     }[];
 }>;
+export declare const DescribeNodeResponseSchema: 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

@@ -94,3 +94,6 @@ export const GetCurrentContextResponseSchema = z.object({
 export const SetCurrentContextResponseSchema = z.object({
     content: z.array(ToolResponseContent),
 });
+export const DescribeNodeResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});

package/dist/tools/delete_service.d.ts

@@ -0,0 +1,32 @@
+import { KubernetesManager } from "../types.js";
+export declare const deleteServiceSchema: {
+    readonly name: "delete_service";
+    readonly description: "Delete a Kubernetes service";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly namespace: {
+                readonly type: "string";
+                readonly default: "default";
+            };
+            readonly ignoreNotFound: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+        };
+        readonly required: readonly ["name"];
+    };
+};
+export declare function deleteService(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace?: string;
+    ignoreNotFound?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/delete_service.js

@@ -0,0 +1,46 @@
+export const deleteServiceSchema = {
+    name: "delete_service",
+    description: "Delete a Kubernetes service",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string", default: "default" },
+            ignoreNotFound: { type: "boolean", default: false },
+        },
+        required: ["name"],
+    },
+};
+export async function deleteService(k8sManager, input) {
+    const namespace = input.namespace || "default";
+    try {
+        await k8sManager.getCoreApi().deleteNamespacedService(input.name, namespace);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        status: "deleted",
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (input.ignoreNotFound && error.response?.statusCode === 404) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            status: "not_found",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        throw error;
+    }
+}

package/dist/tools/describe_node.d.ts

@@ -0,0 +1,22 @@
+import { KubernetesManager } from "../types.js";
+export declare const describeNodeSchema: {
+    readonly name: "describe_node";
+    readonly description: "Describe a Kubernetes node (read details like status, capacity, conditions, etc.)";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["name"];
+    };
+};
+export declare function describeNode(k8sManager: KubernetesManager, input: {
+    name: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

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/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/package.json

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