mcp-server-kubernetes 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Suyog Sonwalkar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# mcp-server-kubernetes
+
+MCP Server that can connect to a Kubernetes cluster and manage it.
+
+## How to run tests locally
+
+```bash
+git clone https://github.com/Flux159/mcp-server-kubernetes.git
+cd mcp-server-kubernetes
+bun install
+bun run test
+```
+
+## Usage with Claude Desktop
+
+Clone the repo, install the dependencies, and build the dist folder:
+
+```
+bun run build
+```
+
+To use this server with the Claude Desktop app, add the following configuration to the "mcpServers" section of your `claude_desktop_config.json`:
+
+Note that you can use `node` or `bun` to run the server. Tests will currently only run properly with bun at the moment though.
+
+```json
+{
+  "mcpServers": {
+    "kubernetes": {
+      "command": "bun",
+      "args": ["/your/path/to/mcp-server-kubernetes/dist/index.js"]
+    }
+  }
+}
+```
+
+The server will automatically connect to your current kubectl context. Make sure you have:
+
+1. kubectl installed and in your PATH
+2. A valid kubeconfig file with contexts configured
+3. Access to a Kubernetes cluster configured for kubectl (e.g. minikube, Rancher Desktop, GKE, etc.)
+
+You can verify your connection by asking Claude to list your pods or create a test deployment.
+
+## Features
+
+- [x] Connect to a Kubernetes cluster
+- [x] List all pods
+- [x] List all services
+- [x] List all deployments
+- [x] Create a pod
+- [x] Delete a pod
+- [x] List all namespaces
+- [] Port forward to a pod
+- [] Get logs from a pod for debugging
+- [] Choose namespace for next commands (memory)
+- [] Support Helm for installing charts
+
+## Not planned
+
+Authentication / adding clusters to kubectx.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,599 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListResourcesRequestSchema, ReadResourceRequestSchema, ListToolsRequestSchema, CallToolRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import * as k8s from "@kubernetes/client-node";
+class KubernetesManager {
+    resources = [];
+    portForwards = [];
+    watches = [];
+    kc;
+    k8sApi;
+    k8sAppsApi;
+    constructor() {
+        this.kc = new k8s.KubeConfig();
+        this.kc.loadFromDefault();
+        this.k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
+        this.k8sAppsApi = this.kc.makeApiClient(k8s.AppsV1Api);
+        // process.on("SIGINT", () => this.cleanup());
+        // process.on("SIGTERM", () => this.cleanup());
+    }
+    async cleanup() {
+        console.log("Cleaning up resources...");
+        // Stop port forwards
+        // for (const pf of this.portForwards) {
+        //   try {
+        //     await pf.server.stop();
+        //   } catch (error) {
+        //     console.error(`Failed to close port-forward ${pf.id}:`, error);
+        //   }
+        // }
+        // Stop watches
+        for (const watch of this.watches) {
+            watch.abort.abort();
+        }
+        // Delete tracked resources in reverse order
+        for (const resource of [...this.resources].reverse()) {
+            try {
+                await this.deleteResource(resource.kind, resource.name, resource.namespace);
+            }
+            catch (error) {
+                console.error(`Failed to delete ${resource.kind} ${resource.name}:`, error);
+            }
+        }
+    }
+    trackResource(kind, name, namespace) {
+        this.resources.push({ kind, name, namespace, createdAt: new Date() });
+    }
+    async deleteResource(kind, name, namespace) {
+        switch (kind.toLowerCase()) {
+            case "pod":
+                await this.k8sApi.deleteNamespacedPod(name, namespace);
+                break;
+            case "deployment":
+                await this.k8sAppsApi.deleteNamespacedDeployment(name, namespace);
+                break;
+            case "service":
+                await this.k8sApi.deleteNamespacedService(name, namespace);
+                break;
+        }
+        this.resources = this.resources.filter((r) => !(r.kind === kind && r.name === name && r.namespace === namespace));
+    }
+    trackPortForward(pf) {
+        this.portForwards.push(pf);
+    }
+    getPortForward(id) {
+        return this.portForwards.find((p) => p.id === id);
+    }
+    removePortForward(id) {
+        this.portForwards = this.portForwards.filter((p) => p.id !== id);
+    }
+    trackWatch(watch) {
+        this.watches.push(watch);
+    }
+    getKubeConfig() {
+        return this.kc;
+    }
+    getCoreApi() {
+        return this.k8sApi;
+    }
+    getAppsApi() {
+        return this.k8sAppsApi;
+    }
+}
+const k8sManager = new KubernetesManager();
+// Template configurations with health checks and resource limits
+const containerTemplates = {
+    ubuntu: {
+        name: "main",
+        image: "ubuntu:latest",
+        command: ["/bin/bash"],
+        args: ["-c", "sleep infinity"],
+        resources: {
+            limits: {
+                cpu: "200m",
+                memory: "256Mi",
+            },
+            requests: {
+                cpu: "100m",
+                memory: "128Mi",
+            },
+        },
+        livenessProbe: {
+            exec: {
+                command: ["cat", "/proc/1/status"],
+            },
+            initialDelaySeconds: 5,
+            periodSeconds: 10,
+        },
+    },
+    nginx: {
+        name: "main",
+        image: "nginx:latest",
+        ports: [{ containerPort: 80 }],
+        resources: {
+            limits: {
+                cpu: "200m",
+                memory: "256Mi",
+            },
+            requests: {
+                cpu: "100m",
+                memory: "128Mi",
+            },
+        },
+        livenessProbe: {
+            httpGet: {
+                path: "/",
+                port: 80,
+            },
+            initialDelaySeconds: 5,
+            periodSeconds: 10,
+        },
+        readinessProbe: {
+            httpGet: {
+                path: "/",
+                port: 80,
+            },
+            initialDelaySeconds: 2,
+            periodSeconds: 5,
+        },
+    },
+    busybox: {
+        name: "main",
+        image: "busybox:latest",
+        command: ["sh"],
+        args: ["-c", "sleep infinity"],
+        resources: {
+            limits: {
+                cpu: "100m",
+                memory: "64Mi",
+            },
+            requests: {
+                cpu: "50m",
+                memory: "32Mi",
+            },
+        },
+        livenessProbe: {
+            exec: {
+                command: ["true"],
+            },
+            periodSeconds: 10,
+        },
+    },
+    alpine: {
+        name: "main",
+        image: "alpine:latest",
+        command: ["sh"],
+        args: ["-c", "sleep infinity"],
+        resources: {
+            limits: {
+                cpu: "100m",
+                memory: "64Mi",
+            },
+            requests: {
+                cpu: "50m",
+                memory: "32Mi",
+            },
+        },
+        livenessProbe: {
+            exec: {
+                command: ["true"],
+            },
+            periodSeconds: 10,
+        },
+    },
+};
+const server = new Server({
+    name: "kubernetes",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+// Tools handlers
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "list_pods",
+                description: "List pods in a namespace",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        namespace: { type: "string", default: "default" },
+                    },
+                    required: ["namespace"],
+                },
+            },
+            {
+                name: "list_deployments",
+                description: "List deployments in a namespace",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        namespace: { type: "string", default: "default" },
+                    },
+                    required: ["namespace"],
+                },
+            },
+            {
+                name: "list_services",
+                description: "List services in a namespace",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        namespace: { type: "string", default: "default" },
+                    },
+                    required: ["namespace"],
+                },
+            },
+            {
+                name: "list_namespaces",
+                description: "List all namespaces",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "create_pod",
+                description: "Create a new Kubernetes pod",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        namespace: { type: "string" },
+                        template: {
+                            type: "string",
+                            enum: ["ubuntu", "nginx", "busybox", "alpine"],
+                        },
+                        command: {
+                            type: "array",
+                            items: { type: "string" },
+                            optional: true,
+                        },
+                    },
+                    required: ["name", "namespace", "template"],
+                },
+            },
+            {
+                name: "create_deployment",
+                description: "Create a new Kubernetes deployment",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        namespace: { type: "string" },
+                        template: {
+                            type: "string",
+                            enum: ["ubuntu", "nginx", "busybox", "alpine"],
+                        },
+                        replicas: { type: "number", default: 1 },
+                        ports: {
+                            type: "array",
+                            items: { type: "number" },
+                            optional: true,
+                        },
+                    },
+                    required: ["name", "namespace", "template"],
+                },
+            },
+            {
+                name: "delete_pod",
+                description: "Delete a Kubernetes pod",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        namespace: { type: "string" },
+                        ignoreNotFound: { type: "boolean", default: false },
+                    },
+                    required: ["name", "namespace"],
+                },
+            },
+            {
+                name: "cleanup",
+                description: "Cleanup all managed resources",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        ],
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        const { name } = request.params;
+        const input = request.params.arguments;
+        switch (name) {
+            case "list_pods": {
+                const listPodsInput = input;
+                const namespace = listPodsInput.namespace || "default";
+                const { body } = await k8sManager
+                    .getCoreApi()
+                    .listNamespacedPod(namespace);
+                const pods = body.items.map((pod) => ({
+                    name: pod.metadata?.name || "",
+                    namespace: pod.metadata?.namespace || "",
+                    status: pod.status?.phase,
+                    createdAt: pod.metadata?.creationTimestamp,
+                }));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ pods }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "list_deployments": {
+                const listDeploymentsInput = input;
+                const namespace = listDeploymentsInput.namespace || "default";
+                const { body } = await k8sManager
+                    .getAppsApi()
+                    .listNamespacedDeployment(namespace);
+                const deployments = body.items.map((deployment) => ({
+                    name: deployment.metadata?.name || "",
+                    namespace: deployment.metadata?.namespace || "",
+                    replicas: deployment.spec?.replicas || 0,
+                    availableReplicas: deployment.status?.availableReplicas || 0,
+                    createdAt: deployment.metadata?.creationTimestamp,
+                }));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ deployments }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "list_services": {
+                const listServicesInput = input;
+                const namespace = listServicesInput.namespace || "default";
+                const { body } = await k8sManager
+                    .getCoreApi()
+                    .listNamespacedService(namespace);
+                const services = body.items.map((service) => ({
+                    name: service.metadata?.name || "",
+                    namespace: service.metadata?.namespace || "",
+                    type: service.spec?.type,
+                    clusterIP: service.spec?.clusterIP,
+                    ports: service.spec?.ports || [],
+                    createdAt: service.metadata?.creationTimestamp,
+                }));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ services }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "list_namespaces": {
+                const { body } = await k8sManager.getCoreApi().listNamespace();
+                const namespaces = body.items.map((ns) => ({
+                    name: ns.metadata?.name || "",
+                    status: ns.status?.phase || "",
+                    createdAt: ns.metadata?.creationTimestamp,
+                }));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ namespaces }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "create_pod": {
+                console.error("calling create_pod");
+                console.error(input);
+                console.error(request);
+                const createPodInput = input;
+                const templateConfig = containerTemplates[createPodInput.template];
+                const pod = {
+                    apiVersion: "v1",
+                    kind: "Pod",
+                    metadata: {
+                        name: createPodInput.name,
+                        namespace: createPodInput.namespace,
+                        labels: {
+                            "mcp-managed": "true",
+                            app: createPodInput.name,
+                        },
+                    },
+                    spec: {
+                        containers: [
+                            {
+                                ...templateConfig,
+                                ...(createPodInput.command && {
+                                    command: createPodInput.command,
+                                }),
+                            },
+                        ],
+                    },
+                };
+                const { body } = await k8sManager
+                    .getCoreApi()
+                    .createNamespacedPod(createPodInput.namespace, pod);
+                k8sManager.trackResource("Pod", createPodInput.name, createPodInput.namespace);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                podName: body.metadata.name,
+                                status: "created",
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "delete_pod": {
+                const deletePodInput = input;
+                try {
+                    await k8sManager
+                        .getCoreApi()
+                        .deleteNamespacedPod(deletePodInput.name, deletePodInput.namespace);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: true,
+                                    status: "deleted",
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    if (deletePodInput.ignoreNotFound &&
+                        error.response?.statusCode === 404) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        success: true,
+                                        status: "not_found",
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    throw error;
+                }
+            }
+            case "cleanup": {
+                await k8sManager.cleanup();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof McpError)
+            throw error;
+        throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error}`);
+    }
+});
+// Resources handlers
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+        resources: [
+            {
+                uri: "k8s://default/pods",
+                name: "Kubernetes Pods",
+                mimeType: "application/json",
+                description: "List of pods in the default namespace",
+            },
+            {
+                uri: "k8s://default/deployments",
+                name: "Kubernetes Deployments",
+                mimeType: "application/json",
+                description: "List of deployments in the default namespace",
+            },
+            {
+                uri: "k8s://default/services",
+                name: "Kubernetes Services",
+                mimeType: "application/json",
+                description: "List of services in the default namespace",
+            },
+            {
+                uri: "k8s://namespaces",
+                name: "Kubernetes Namespaces",
+                mimeType: "application/json",
+                description: "List of all namespaces",
+            },
+        ],
+    };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    try {
+        const uri = request.params.uri;
+        const parts = uri.replace("k8s://", "").split("/");
+        if (parts[0] === "namespaces" && parts.length === 1) {
+            const { body } = await k8sManager.getCoreApi().listNamespace();
+            return {
+                contents: [
+                    {
+                        uri: request.params.uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(body.items, null, 2),
+                    },
+                ],
+            };
+        }
+        const [namespace, resourceType] = parts;
+        switch (resourceType) {
+            case "pods": {
+                const { body } = await k8sManager
+                    .getCoreApi()
+                    .listNamespacedPod(namespace);
+                return {
+                    contents: [
+                        {
+                            uri: request.params.uri,
+                            mimeType: "application/json",
+                            text: JSON.stringify(body.items, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "deployments": {
+                const { body } = await k8sManager
+                    .getAppsApi()
+                    .listNamespacedDeployment(namespace);
+                return {
+                    contents: [
+                        {
+                            uri: request.params.uri,
+                            mimeType: "application/json",
+                            text: JSON.stringify(body.items, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "services": {
+                const { body } = await k8sManager
+                    .getCoreApi()
+                    .listNamespacedService(namespace);
+                return {
+                    contents: [
+                        {
+                            uri: request.params.uri,
+                            mimeType: "application/json",
+                            text: JSON.stringify(body.items, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new McpError(ErrorCode.InvalidRequest, `Unsupported resource type: ${resourceType}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof McpError)
+            throw error;
+        throw new McpError(ErrorCode.InternalError, `Failed to read resource: ${error}`);
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/types.d.ts

@@ -0,0 +1,312 @@
+import { z } from "zod";
+export declare const ContainerTemplate: z.ZodEnum<["ubuntu", "nginx", "busybox", "alpine"]>;
+export declare const ResourceSchema: z.ZodObject<{
+    uri: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uri: string;
+    name: string;
+    description: string;
+}, {
+    uri: string;
+    name: string;
+    description: string;
+}>;
+export declare const ToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+}, {
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+}>;
+export declare const ListToolsResponseSchema: z.ZodObject<{
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }, {
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tools: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }[];
+}, {
+    tools: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }[];
+}>;
+export declare const CreatePodResponseSchema: 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 CreateDeploymentResponseSchema: 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 DeletePodResponseSchema: 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 CleanupResponseSchema: 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 ListPodsResponseSchema: 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 ListDeploymentsResponseSchema: 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 ListServicesResponseSchema: 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 ListNamespacesResponseSchema: 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 ListResourcesResponseSchema: z.ZodObject<{
+    resources: z.ZodArray<z.ZodObject<{
+        uri: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        uri: string;
+        name: string;
+        description: string;
+    }, {
+        uri: string;
+        name: string;
+        description: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    resources: {
+        uri: string;
+        name: string;
+        description: string;
+    }[];
+}, {
+    resources: {
+        uri: string;
+        name: string;
+        description: string;
+    }[];
+}>;
+export declare const ReadResourceResponseSchema: z.ZodObject<{
+    contents: z.ZodArray<z.ZodObject<{
+        uri: z.ZodString;
+        mimeType: z.ZodString;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        uri: string;
+        text: string;
+        mimeType: string;
+    }, {
+        uri: string;
+        text: string;
+        mimeType: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    contents: {
+        uri: string;
+        text: string;
+        mimeType: string;
+    }[];
+}, {
+    contents: {
+        uri: string;
+        text: string;
+        mimeType: string;
+    }[];
+}>;
+export type K8sResource = z.infer<typeof ResourceSchema>;
+export type K8sTool = z.infer<typeof ToolSchema>;
+export interface ResourceTracker {
+    kind: string;
+    name: string;
+    namespace: string;
+    createdAt: Date;
+}
+export interface PortForwardTracker {
+    id: string;
+    server: {
+        stop: () => Promise<void>;
+    };
+    resourceType: string;
+    name: string;
+    namespace: string;
+    ports: {
+        local: number;
+        remote: number;
+    }[];
+}
+export interface WatchTracker {
+    id: string;
+    abort: AbortController;
+    resourceType: string;
+    namespace: string;
+}

package/dist/types.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+// Kubernetes-specific types
+export const ContainerTemplate = z.enum([
+    "ubuntu",
+    "nginx",
+    "busybox",
+    "alpine",
+]);
+// Resource response schemas
+export const ResourceSchema = z.object({
+    uri: z.string(),
+    name: z.string(),
+    description: z.string(),
+});
+// Tool response schemas
+export const ToolSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    inputSchema: z.record(z.any()),
+});
+export const ListToolsResponseSchema = z.object({
+    tools: z.array(ToolSchema),
+});
+// Tool-specific response schemas
+export const CreatePodResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
+export const CreateDeploymentResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
+export const DeletePodResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
+export const CleanupResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
+export const ListPodsResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
+export const ListDeploymentsResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
+export const ListServicesResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
+export const ListNamespacesResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
+export const ListResourcesResponseSchema = z.object({
+    resources: z.array(ResourceSchema),
+});
+export const ReadResourceResponseSchema = z.object({
+    contents: z.array(z.object({
+        uri: z.string(),
+        mimeType: z.string(),
+        text: z.string(),
+    })),
+});

package/dist/unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/unit.test.js

@@ -0,0 +1,141 @@
+import { expect, test } from "vitest";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { ListToolsResponseSchema, ListPodsResponseSchema, ListDeploymentsResponseSchema, ListNamespacesResponseSchema, CreatePodResponseSchema, DeletePodResponseSchema, CleanupResponseSchema, } from "./types.js";
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+test("kubernetes server operations", async () => {
+    const transport = new StdioClientTransport({
+        command: "bun",
+        args: ["src/index.ts"],
+        stderr: "pipe",
+    });
+    const client = new Client({
+        name: "test-client",
+        version: "1.0.0",
+    }, {
+        capabilities: {},
+    });
+    await client.connect(transport);
+    try {
+        // List available tools stays the same
+        console.log("Listing available tools...");
+        const toolsList = await client.request({
+            method: "tools/list",
+        }, ListToolsResponseSchema);
+        expect(toolsList.tools).toBeDefined();
+        expect(toolsList.tools.length).toBeGreaterThan(0);
+        // List namespaces
+        console.log("Listing namespaces...");
+        const namespacesResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "list_namespaces",
+                arguments: {}, // Changed from input to arguments
+            },
+        }, ListNamespacesResponseSchema);
+        expect(namespacesResult.content[0].type).toBe("text");
+        const namespaces = JSON.parse(namespacesResult.content[0].text);
+        expect(namespaces.namespaces).toBeDefined();
+        // Delete test pod if it exists
+        console.log("Deleting test pod if exists...");
+        const deletePodResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "delete_pod",
+                arguments: {
+                    // Changed from input to arguments
+                    name: "test-pod",
+                    namespace: "default",
+                    ignoreNotFound: true,
+                },
+            },
+        }, DeletePodResponseSchema);
+        expect(deletePodResult.content[0].type).toBe("text");
+        const deleteResult = JSON.parse(deletePodResult.content[0].text);
+        expect(deleteResult.success).toBe(true);
+        await sleep(2000);
+        // Create a pod
+        console.log("Creating test pod...");
+        const createPodResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "create_pod",
+                arguments: {
+                    // Changed from input to arguments
+                    name: "test-pod",
+                    namespace: "default",
+                    template: "nginx",
+                },
+            },
+        }, CreatePodResponseSchema);
+        expect(createPodResult.content[0].type).toBe("text");
+        const createResult = JSON.parse(createPodResult.content[0].text);
+        expect(createResult.podName).toBe("test-pod");
+        expect(createResult.status).toBe("created");
+        // List pods to verify creation
+        console.log("Listing pods...");
+        const listPodsResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "list_pods",
+                arguments: {
+                    // Changed from input to arguments
+                    namespace: "default",
+                },
+            },
+        }, ListPodsResponseSchema);
+        expect(listPodsResult.content[0].type).toBe("text");
+        const pods = JSON.parse(listPodsResult.content[0].text);
+        expect(pods.pods).toBeDefined();
+        expect(pods.pods.some((pod) => pod.name === "test-pod")).toBe(true);
+        // List deployments
+        console.log("Listing deployments...");
+        const listDeploymentsResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "list_deployments",
+                arguments: {
+                    // Changed from input to arguments
+                    namespace: "default",
+                },
+            },
+        }, ListDeploymentsResponseSchema);
+        expect(listDeploymentsResult.content[0].type).toBe("text");
+        const deployments = JSON.parse(listDeploymentsResult.content[0].text);
+        expect(deployments.deployments).toBeDefined();
+        // Cleanup
+        console.log("Cleaning up...");
+        const cleanupResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "cleanup",
+                arguments: {}, // Changed from input to arguments
+            },
+        }, CleanupResponseSchema);
+        expect(cleanupResult.content[0].type).toBe("text");
+        const cleanupData = JSON.parse(cleanupResult.content[0].text);
+        expect(cleanupData.success).toBe(true);
+        // Verify cleanup by listing pods again
+        console.log("Verifying cleanup...");
+        const finalPodsResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "list_pods",
+                arguments: {
+                    // Changed from input to arguments
+                    namespace: "default",
+                },
+            },
+        }, ListPodsResponseSchema);
+        const finalPods = JSON.parse(finalPodsResult.content[0].text);
+        console.log(finalPods);
+        // expect(finalPods.pods.some((pod: any) => pod.name === "test-pod")).toBe(
+        //   false
+        // );
+    }
+    finally {
+        // await client.disconnect();  // Re-enabled client disconnect
+    }
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "mcp-server-kubernetes",
+  "version": "0.1.0",
+  "description": "MCP server for interacting with Kubernetes clusters via kubectl",
+  "license": "MIT",
+  "type": "module",
+  "author": "Flux159",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Flux159/mcp-server-kubernetes"
+  },
+  "bin": {
+    "mcp-server-kubernetes": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "vitest --testTimeout=20000",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "kubernetes",
+    "claude",
+    "anthropic",
+    "kubectl"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@kubernetes/client-node": "^0.20.0",
+    "@modelcontextprotocol/sdk": "1.0.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.9.3",
+    "shx": "^0.3.4",
+    "typescript": "^5.6.2",
+    "vitest": "2.1.8"
+  }
+}