mcp-server-kubernetes 0.1.4 → 0.1.5

package/README.md

@@ -24,6 +24,7 @@ The server will automatically connect to your current kubectl context. Make sure
 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.)
+4. Helm v3 installed and in your PATH (no Tiller required)
 
 You can verify your connection by asking Claude to list your pods or create a test deployment.
 
@@ -41,9 +42,15 @@ If you have errors, open up a standard terminal and run `kubectl get pods` to se
 - [x] Describe a pod
 - [x] List all namespaces
 - [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
+  - Uninstall releases
+  - Upgrade existing releases
+  - Support for namespaces
+  - Support for version specification
+  - Support for custom repositories
 - [ ] Port forward to a pod
 - [ ] Choose namespace for next commands (memory)
-- [ ] Support Helm for installing charts
 
 ## Local Development
 
@@ -86,6 +93,7 @@ npx @modelcontextprotocol/inspector node build/index.js
 src/
 ├── index.ts     # Main server implementation
 ├── types.ts     # TypeScript type definitions
+├── helm.test.ts # Helm chart installation tests
 └── unit.test.ts # Unit tests
 ```
 

package/dist/helm.test.d.ts

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

package/dist/helm.test.js

@@ -0,0 +1,208 @@
+import { expect, test, describe, beforeEach, afterEach } from "vitest";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { HelmResponseSchema } from "./types.js";
+import * as fs from "fs";
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+describe("helm operations", () => {
+    let transport;
+    let client;
+    const testReleaseName = "test-nginx";
+    const testNamespace = "default";
+    beforeEach(async () => {
+        try {
+            transport = new StdioClientTransport({
+                command: "bun",
+                args: ["src/index.ts"],
+                stderr: "pipe",
+            });
+            client = new Client({
+                name: "test-client",
+                version: "1.0.0",
+            }, {
+                capabilities: {},
+            });
+            await client.connect(transport);
+            await sleep(1000);
+        }
+        catch (e) {
+            console.error("Error in beforeEach:", e);
+            throw e;
+        }
+    });
+    afterEach(async () => {
+        try {
+            // Cleanup: Uninstall the test release if it exists
+            await client
+                .request({
+                method: "tools/call",
+                params: {
+                    name: "uninstall_helm_chart",
+                    arguments: {
+                        name: testReleaseName,
+                        namespace: testNamespace,
+                    },
+                },
+            }, HelmResponseSchema)
+                .catch(() => { }); // Ignore errors if release doesn't exist
+            await transport.close();
+            await sleep(1000);
+            // Cleanup generated values files
+            if (fs.existsSync("test-nginx-values.yaml")) {
+                fs.unlinkSync("test-nginx-values.yaml");
+            }
+        }
+        catch (e) {
+            console.error("Error during cleanup:", e);
+        }
+    });
+    test("install helm chart", async () => {
+        const installResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "install_helm_chart",
+                arguments: {
+                    name: testReleaseName,
+                    chart: "nginx",
+                    repo: "https://charts.bitnami.com/bitnami",
+                    namespace: testNamespace,
+                    values: {
+                        service: {
+                            type: "ClusterIP",
+                        },
+                        resources: {
+                            limits: {
+                                cpu: "100m",
+                                memory: "128Mi",
+                            },
+                            requests: {
+                                cpu: "50m",
+                                memory: "64Mi",
+                            },
+                        },
+                    },
+                },
+            },
+        }, HelmResponseSchema);
+        expect(installResult.content[0].type).toBe("text");
+        const result = JSON.parse(installResult.content[0].text);
+        expect(result.status).toBe("installed");
+        // Wait for the deployment to be ready
+        await sleep(5000);
+        // Verify the deployment exists
+        const deploymentResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "list_deployments",
+                arguments: {
+                    namespace: testNamespace,
+                },
+            },
+        }, HelmResponseSchema);
+        const deployments = JSON.parse(deploymentResult.content[0].text);
+        expect(deployments.deployments.some((d) => d.name.startsWith(testReleaseName))).toBe(true);
+    }, 30000); // Increase timeout to 30s for chart installation
+    test("upgrade helm chart values", async () => {
+        // First install the chart
+        await client.request({
+            method: "tools/call",
+            params: {
+                name: "install_helm_chart",
+                arguments: {
+                    name: testReleaseName,
+                    chart: "nginx",
+                    repo: "https://charts.bitnami.com/bitnami",
+                    namespace: testNamespace,
+                },
+            },
+        }, HelmResponseSchema);
+        await sleep(5000);
+        // Then upgrade it with new values
+        const upgradeResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "upgrade_helm_chart",
+                arguments: {
+                    name: testReleaseName,
+                    chart: "nginx",
+                    repo: "https://charts.bitnami.com/bitnami",
+                    namespace: testNamespace,
+                    values: {
+                        replicaCount: 2,
+                        resources: {
+                            limits: {
+                                cpu: "200m",
+                                memory: "256Mi",
+                            },
+                        },
+                    },
+                },
+            },
+        }, HelmResponseSchema);
+        expect(upgradeResult.content[0].type).toBe("text");
+        const result = JSON.parse(upgradeResult.content[0].text);
+        expect(result.status).toBe("upgraded");
+        // Wait for the upgrade to take effect
+        await sleep(5000);
+        // Verify the deployment was updated
+        const deploymentResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "list_deployments",
+                arguments: {
+                    namespace: testNamespace,
+                },
+            },
+        }, HelmResponseSchema);
+        const deployments = JSON.parse(deploymentResult.content[0].text);
+        const nginxDeployment = deployments.deployments.find((d) => d.name.startsWith(testReleaseName));
+        expect(nginxDeployment).toBeDefined();
+        expect(nginxDeployment.replicas).toBe(2);
+    }, 60000); // Increase timeout to 60s for install + upgrade
+    test("uninstall helm chart", async () => {
+        // First install the chart
+        await client.request({
+            method: "tools/call",
+            params: {
+                name: "install_helm_chart",
+                arguments: {
+                    name: testReleaseName,
+                    chart: "nginx",
+                    repo: "https://charts.bitnami.com/bitnami",
+                    namespace: testNamespace,
+                },
+            },
+        }, HelmResponseSchema);
+        await sleep(5000);
+        // Then uninstall it
+        const uninstallResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "uninstall_helm_chart",
+                arguments: {
+                    name: testReleaseName,
+                    namespace: testNamespace,
+                },
+            },
+        }, HelmResponseSchema);
+        expect(uninstallResult.content[0].type).toBe("text");
+        const result = JSON.parse(uninstallResult.content[0].text);
+        expect(result.status).toBe("uninstalled");
+        // Wait for resources to be cleaned up
+        await sleep(5000);
+        // Verify the deployment is gone
+        const deploymentResult = await client.request({
+            method: "tools/call",
+            params: {
+                name: "list_deployments",
+                arguments: {
+                    namespace: testNamespace,
+                },
+            },
+        }, HelmResponseSchema);
+        const deployments = JSON.parse(deploymentResult.content[0].text);
+        expect(deployments.deployments.every((d) => !d.name.startsWith(testReleaseName))).toBe(true);
+    }, 60000); // Increase timeout to 60s for install + uninstall
+});

package/dist/index.js

@@ -3,6 +3,9 @@ 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";
+import * as fs from "fs/promises";
+import * as yaml from "js-yaml";
+import { exec } from "child_process";
 class KubernetesManager {
     resources = [];
     portForwards = [];
@@ -185,6 +188,18 @@ const server = new Server({
         tools: {},
     },
 });
+// Helper function to execute shell commands
+function execCommand(command) {
+    return new Promise((resolve, reject) => {
+        exec(command, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(`Command failed: ${error.message}\n${stderr}`));
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}
 // Tools handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
@@ -365,6 +380,71 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["resourceType"],
                 },
             },
+            {
+                name: "install_helm_chart",
+                description: "Install a Helm chart",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Release name" },
+                        chart: { type: "string", description: "Chart name or URL" },
+                        namespace: {
+                            type: "string",
+                            description: "Target namespace",
+                            optional: true,
+                        },
+                        values: {
+                            type: "object",
+                            description: "Values to override",
+                            optional: true,
+                        },
+                        version: {
+                            type: "string",
+                            description: "Chart version",
+                            optional: true,
+                        },
+                        repo: {
+                            type: "string",
+                            description: "Chart repository URL",
+                            optional: true,
+                        },
+                    },
+                    required: ["name", "chart"],
+                },
+            },
+            {
+                name: "uninstall_helm_chart",
+                description: "Uninstall a Helm release",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Release name" },
+                        namespace: {
+                            type: "string",
+                            description: "Release namespace",
+                            optional: true,
+                        },
+                    },
+                    required: ["name"],
+                },
+            },
+            {
+                name: "upgrade_helm_chart",
+                description: "Upgrade a Helm release with new values",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Release name" },
+                        values: { type: "object", description: "New values to apply" },
+                        namespace: {
+                            type: "string",
+                            description: "Release namespace",
+                            optional: true,
+                        },
+                    },
+                    required: ["name", "values"],
+                },
+            },
         ],
     };
 });
@@ -738,6 +818,70 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     throw new McpError(ErrorCode.InternalError, `Failed to get logs: ${error}`);
                 }
             }
+            case "install_helm_chart": {
+                const installInput = input;
+                let command = `helm install ${installInput.name} ${installInput.chart}`;
+                if (installInput.namespace) {
+                    command += ` -n ${installInput.namespace}`;
+                }
+                if (installInput.values) {
+                    const valuesFile = `${installInput.name}-values.yaml`;
+                    await fs.writeFile(valuesFile, yaml.dump(installInput.values));
+                    command += ` -f ${valuesFile}`;
+                }
+                if (installInput.version) {
+                    command += ` --version ${installInput.version}`;
+                }
+                if (installInput.repo) {
+                    command += ` --repo ${installInput.repo}`;
+                }
+                const result = await execCommand(command);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ status: "installed", output: result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "uninstall_helm_chart": {
+                const uninstallInput = input;
+                let command = `helm uninstall ${uninstallInput.name}`;
+                if (uninstallInput.namespace) {
+                    command += ` -n ${uninstallInput.namespace}`;
+                }
+                const result = await execCommand(command);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ status: "uninstalled", output: result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "upgrade_helm_chart": {
+                const upgradeInput = input;
+                const valuesFile = `${upgradeInput.name}-values.yaml`;
+                await fs.writeFile(valuesFile, yaml.dump(upgradeInput.values));
+                let command = `helm upgrade ${upgradeInput.name} ${upgradeInput.chart} -f ${valuesFile}`;
+                if (upgradeInput.namespace) {
+                    command += ` -n ${upgradeInput.namespace}`;
+                }
+                if (upgradeInput.repo) {
+                    command += ` --repo ${upgradeInput.repo}`;
+                }
+                const result = await execCommand(command);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ status: "upgraded", output: result }, null, 2),
+                        },
+                    ],
+                };
+            }
             default:
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
         }

package/dist/types.d.ts

@@ -354,3 +354,80 @@ export interface WatchTracker {
     resourceType: string;
     namespace: string;
 }
+export declare const HelmInstallRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    chart: z.ZodString;
+    namespace: z.ZodOptional<z.ZodString>;
+    values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    version: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    chart: string;
+    values?: Record<string, any> | undefined;
+    namespace?: string | undefined;
+    version?: string | undefined;
+    repo?: string | undefined;
+}, {
+    name: string;
+    chart: string;
+    values?: Record<string, any> | undefined;
+    namespace?: string | undefined;
+    version?: string | undefined;
+    repo?: string | undefined;
+}>;
+export declare const HelmUninstallRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    namespace: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    namespace?: string | undefined;
+}, {
+    name: string;
+    namespace?: string | undefined;
+}>;
+export declare const HelmUpgradeRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    chart: z.ZodString;
+    repo: z.ZodOptional<z.ZodString>;
+    values: z.ZodRecord<z.ZodString, z.ZodAny>;
+    namespace: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    values: Record<string, any>;
+    chart: string;
+    namespace?: string | undefined;
+    repo?: string | undefined;
+}, {
+    name: string;
+    values: Record<string, any>;
+    chart: string;
+    namespace?: string | undefined;
+    repo?: string | undefined;
+}>;
+export declare const HelmResponseSchema: 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 type HelmInstallRequest = z.infer<typeof HelmInstallRequestSchema>;
+export type HelmUninstallRequest = z.infer<typeof HelmUninstallRequestSchema>;
+export type HelmUpgradeRequest = z.infer<typeof HelmUpgradeRequestSchema>;
+export type HelmResponse = z.infer<typeof HelmResponseSchema>;

package/dist/types.js

@@ -92,3 +92,29 @@ export const ReadResourceResponseSchema = z.object({
         text: z.string(),
     })),
 });
+// Helm-related types
+export const HelmInstallRequestSchema = z.object({
+    name: z.string(),
+    chart: z.string(),
+    namespace: z.string().optional(),
+    values: z.record(z.any()).optional(),
+    version: z.string().optional(),
+    repo: z.string().optional(),
+});
+export const HelmUninstallRequestSchema = z.object({
+    name: z.string(),
+    namespace: z.string().optional(),
+});
+export const HelmUpgradeRequestSchema = z.object({
+    name: z.string(),
+    chart: z.string(),
+    repo: z.string().optional(),
+    values: z.record(z.any()),
+    namespace: z.string().optional(),
+});
+export const HelmResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});

package/dist/unit.test.js

@@ -184,7 +184,11 @@ describe("kubernetes server operations", () => {
                     name: podName,
                     namespace: "default",
                     template: "busybox",
-                    command: ["/bin/sh", "-c", "echo Pod is running && sleep infinity"],
+                    command: [
+                        "/bin/sh",
+                        "-c",
+                        "echo Pod is running && sleep infinity",
+                    ],
                 },
             },
         }, CreatePodResponseSchema);
@@ -285,5 +289,5 @@ describe("kubernetes server operations", () => {
             // Ignore any errors during termination check
             console.log(`Error checking pod termination status: ${error}`);
         }
-    });
+    }, { timeout: 120000 });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -36,9 +36,11 @@
   "dependencies": {
     "@kubernetes/client-node": "^0.20.0",
     "@modelcontextprotocol/sdk": "1.0.1",
+    "js-yaml": "^4.1.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.9.3",
     "shx": "^0.3.4",
     "typescript": "^5.6.2",