mcp-server-kubernetes 1.3.2 → 1.5.0

package/README.md

@@ -67,9 +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, 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
@@ -82,9 +84,12 @@ 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
 
+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
@@ -134,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
@@ -143,7 +148,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

@@ -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,57 +26,90 @@ 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 { createConfigMap, CreateConfigMapSchema } from "./tools/create_configmap.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 { 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 k8sManager = new KubernetesManager();
 const server = new Server({
     name: serverConfig.name,
     version: serverConfig.version,
 }, serverConfig);
+// Define destructive tools (delete and uninstall operations)
+const destructiveTools = [
+    deletePodSchema,
+    deleteServiceSchema,
+    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,
+        deleteServiceSchema,
+        describeCronJobSchema,
+        describePodSchema,
+        describeNodeSchema,
+        describeDeploymentSchema,
+        describeServiceSchema,
+        explainResourceSchema,
+        getEventsSchema,
+        getJobLogsSchema,
+        getLogsSchema,
+        installHelmChartSchema,
+        listApiResourcesSchema,
+        listCronJobsSchema,
+        listContextsSchema,
+        getCurrentContextSchema,
+        setCurrentContextSchema,
+        listDeploymentsSchema,
+        listJobsSchema,
+        listNamespacesSchema,
+        listNodesSchema,
+        listPodsSchema,
+        listServicesSchema,
+        uninstallHelmChartSchema,
+        updateDeploymentSchema,
+        upgradeHelmChartSchema,
+        PortForwardSchema,
+        StopPortForwardSchema,
+        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;
+    return { tools };
 });
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
@@ -112,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);
             }
@@ -158,6 +195,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 +234,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 +246,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "create_configmap": {
                 return await createConfigMap(k8sManager, input);
             }
+            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

@@ -505,3 +505,91 @@ 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;
+    }[];
+}>;
+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

@@ -85,3 +85,15 @@ 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),
+});
+export const DescribeNodeResponseSchema = 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/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;
+    }[];
+}>;