mcp-server-kubernetes 0.1.3 → 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.
 
@@ -40,14 +41,16 @@ If you have errors, open up a standard terminal and run `kubectl get pods` to se
 - [x] Delete a pod
 - [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
-- [ ] Get logs from a pod for debugging
 - [ ] Choose namespace for next commands (memory)
-- [ ] Support Helm for installing charts
-
-## In Progress
-
-- [ ] [Docker support](https://github.com/Flux159/mcp-server-kubernetes/pull/9)
 
 ## Local Development
 
@@ -90,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 {
@@ -316,6 +331,120 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {},
                 },
             },
+            {
+                name: "get_logs",
+                description: "Get logs from pods, deployments, jobs, or resources matching a label selector",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        resourceType: {
+                            type: "string",
+                            enum: ["pod", "deployment", "job"],
+                            description: "Type of resource to get logs from",
+                        },
+                        name: {
+                            type: "string",
+                            description: "Name of the resource",
+                        },
+                        namespace: {
+                            type: "string",
+                            description: "Namespace of the resource",
+                            default: "default",
+                        },
+                        labelSelector: {
+                            type: "string",
+                            description: "Label selector to filter resources",
+                            optional: true,
+                        },
+                        container: {
+                            type: "string",
+                            description: "Container name (required when pod has multiple containers)",
+                            optional: true,
+                        },
+                        tail: {
+                            type: "number",
+                            description: "Number of lines to show from end of logs",
+                            optional: true,
+                        },
+                        since: {
+                            type: "number",
+                            description: "Get logs since relative time in seconds",
+                            optional: true,
+                        },
+                        timestamps: {
+                            type: "boolean",
+                            description: "Include timestamps in logs",
+                            default: false,
+                        },
+                    },
+                    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"],
+                },
+            },
         ],
     };
 });
@@ -426,21 +555,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 ...templateConfig,
                                 ...(createPodInput.command && {
                                     command: createPodInput.command,
+                                    args: undefined, // Clear default args when command is overridden
                                 }),
                             },
                         ],
                     },
                 };
-                const { body } = await k8sManager
+                const response = await k8sManager
                     .getCoreApi()
-                    .createNamespacedPod(createPodInput.namespace, pod);
+                    .createNamespacedPod(createPodInput.namespace, pod)
+                    .catch((error) => {
+                    console.error("Pod creation error:", {
+                        status: error.response?.statusCode,
+                        message: error.response?.body?.message || error.message,
+                        details: error.response?.body,
+                    });
+                    throw error;
+                });
                 k8sManager.trackResource("Pod", createPodInput.name, createPodInput.namespace);
                 return {
                     content: [
                         {
                             type: "text",
                             text: JSON.stringify({
-                                podName: body.metadata.name,
+                                podName: response.body.metadata.name,
                                 status: "created",
                             }, null, 2),
                         },
@@ -580,6 +718,170 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "get_logs": {
+                const { resourceType, name, namespace = "default", labelSelector, container, tail = 100, sinceSeconds, timestamps, pretty = true, follow = false, } = input;
+                async function getPodLogs(podName, podNamespace) {
+                    try {
+                        const { body } = await k8sManager.getCoreApi().readNamespacedPodLog(podName, podNamespace, container, follow, undefined, // insecureSkipTLSVerifyBackend
+                        undefined, // limitBytes
+                        pretty ? "true" : "false", undefined, // previous
+                        sinceSeconds, tail, timestamps);
+                        return body;
+                    }
+                    catch (error) {
+                        if (error.response?.statusCode === 404) {
+                            throw new McpError(ErrorCode.InvalidRequest, `Pod ${podName} not found in namespace ${podNamespace}`);
+                        }
+                        // Log full error details
+                        console.error("Full error:", {
+                            statusCode: error.response?.statusCode,
+                            message: error.response?.body?.message || error.message,
+                            details: error.response?.body,
+                        });
+                        throw new McpError(ErrorCode.InternalError, `Failed to get logs for pod ${podName}: ${error.response?.body?.message || error.message}`);
+                    }
+                }
+                const logs = {};
+                try {
+                    // Get logs based on resource type
+                    switch (resourceType.toLowerCase()) {
+                        case "pod": {
+                            if (!name) {
+                                throw new McpError(ErrorCode.InvalidRequest, "Pod name is required when resourceType is 'pod'");
+                            }
+                            logs[name] = await getPodLogs(name, namespace);
+                            break;
+                        }
+                        case "deployment": {
+                            if (!name) {
+                                throw new McpError(ErrorCode.InvalidRequest, "Deployment name is required when resourceType is 'deployment'");
+                            }
+                            const { body: deployment } = await k8sManager
+                                .getAppsApi()
+                                .readNamespacedDeployment(name, namespace);
+                            if (!deployment.spec?.selector?.matchLabels) {
+                                throw new McpError(ErrorCode.InvalidRequest, `Deployment ${name} has no selector`);
+                            }
+                            const selector = Object.entries(deployment.spec.selector.matchLabels)
+                                .map(([key, value]) => `${key}=${value}`)
+                                .join(",");
+                            const { body: podList } = await k8sManager
+                                .getCoreApi()
+                                .listNamespacedPod(namespace, undefined, undefined, undefined, undefined, selector);
+                            for (const pod of podList.items) {
+                                if (pod.metadata?.name) {
+                                    logs[pod.metadata.name] = await getPodLogs(pod.metadata.name, namespace);
+                                }
+                            }
+                            break;
+                        }
+                        case "job": {
+                            if (!name) {
+                                throw new McpError(ErrorCode.InvalidRequest, "Job name is required when resourceType is 'job'");
+                            }
+                            const { body: podList } = await k8sManager
+                                .getCoreApi()
+                                .listNamespacedPod(namespace, undefined, undefined, undefined, undefined, `job-name=${name}`);
+                            for (const pod of podList.items) {
+                                if (pod.metadata?.name) {
+                                    logs[pod.metadata.name] = await getPodLogs(pod.metadata.name, namespace);
+                                }
+                            }
+                            break;
+                        }
+                        default:
+                            throw new McpError(ErrorCode.InvalidRequest, `Unsupported resource type: ${resourceType}`);
+                    }
+                    // If labelSelector is provided, filter or add logs by label
+                    if (labelSelector) {
+                        const { body: labeledPods } = await k8sManager
+                            .getCoreApi()
+                            .listNamespacedPod(namespace, undefined, undefined, undefined, undefined, labelSelector);
+                        for (const pod of labeledPods.items) {
+                            if (pod.metadata?.name) {
+                                logs[pod.metadata.name] = await getPodLogs(pod.metadata.name, namespace);
+                            }
+                        }
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({ logs }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    if (error instanceof McpError)
+                        throw error;
+                    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

@@ -251,6 +251,28 @@ export declare const ListNodesResponseSchema: z.ZodObject<{
         text: string;
     }[];
 }>;
+export declare const GetLogsResponseSchema: 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;
@@ -332,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

@@ -76,6 +76,12 @@ export const ListNodesResponseSchema = z.object({
         text: z.string(),
     })),
 });
+export const GetLogsResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
 export const ListResourcesResponseSchema = z.object({
     resources: z.array(ResourceSchema),
 });
@@ -86,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

@@ -1,24 +1,79 @@
-import { expect, test } from "vitest";
+// Import required test frameworks and SDK components
+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 { ListToolsResponseSchema, ListPodsResponseSchema, ListDeploymentsResponseSchema, ListNamespacesResponseSchema, ListNodesResponseSchema, CreatePodResponseSchema, DeletePodResponseSchema, CleanupResponseSchema, } from "./types.js";
+import { ListToolsResponseSchema, ListPodsResponseSchema, ListNamespacesResponseSchema, ListNodesResponseSchema, CreatePodResponseSchema, DeletePodResponseSchema, } from "./types.js";
+/**
+ * Utility function to create a promise that resolves after specified milliseconds
+ * Useful for waiting between operations or ensuring async operations complete
+ */
 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",
+/**
+ * Generates a random SHA-like string for unique resource naming
+ * Used to avoid naming conflicts when creating test resources
+ */
+function generateRandomSHA() {
+    return Math.random().toString(36).substring(2, 15);
+}
+/**
+ * Test suite for kubernetes server operations
+ * Tests the core functionality of kubernetes operations including:
+ * - Listing available tools
+ * - Namespace and node operations
+ * - Pod lifecycle management (create, monitor, delete)
+ */
+describe("kubernetes server operations", () => {
+    let transport;
+    let client;
+    /**
+     * Set up before each test:
+     * - Creates a new StdioClientTransport instance
+     * - Initializes and connects the MCP client
+     * - Waits for connection to be established
+     */
+    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);
+            // Wait for connection to be fully established
+            await sleep(1000);
+        }
+        catch (e) {
+            console.error("Error in beforeEach:", e);
+            throw e;
+        }
     });
-    const client = new Client({
-        name: "test-client",
-        version: "1.0.0",
-    }, {
-        capabilities: {},
+    /**
+     * Clean up after each test:
+     * - Closes the transport connection
+     * - Waits to ensure clean shutdown
+     */
+    afterEach(async () => {
+        try {
+            await transport.close();
+            await sleep(1000);
+        }
+        catch (e) {
+            console.error("Error during cleanup:", e);
+        }
     });
-    await client.connect(transport);
-    try {
+    /**
+     * Test case: Verify the availability of kubernetes tools
+     * Ensures that the server exposes the expected kubernetes operations
+     */
+    test("list available tools", async () => {
         // List available tools stays the same
         console.log("Listing available tools...");
         const toolsList = await client.request({
@@ -26,13 +81,19 @@ test("kubernetes server operations", async () => {
         }, ListToolsResponseSchema);
         expect(toolsList.tools).toBeDefined();
         expect(toolsList.tools.length).toBeGreaterThan(0);
+    });
+    /**
+     * Test case: Verify namespace and node listing functionality
+     * Tests both namespace and node listing operations in sequence
+     */
+    test("list namespaces and nodes", async () => {
         // List namespaces
         console.log("Listing namespaces...");
         const namespacesResult = await client.request({
             method: "tools/call",
             params: {
                 name: "list_namespaces",
-                arguments: {}, // Changed from input to arguments
+                arguments: {},
             },
         }, ListNamespacesResponseSchema);
         expect(namespacesResult.content[0].type).toBe("text");
@@ -51,122 +112,182 @@ test("kubernetes server operations", async () => {
         const nodes = JSON.parse(listNodesResult.content[0].text);
         expect(nodes.nodes).toBeDefined();
         expect(Array.isArray(nodes.nodes)).toBe(true);
-        // Delete test pod if it exists
-        console.log("Deleting test pod if exists...");
-        const deletePodResult = await client.request({
+    });
+    /**
+     * Test case: Complete pod lifecycle management
+     * Tests the full lifecycle of a pod including:
+     * 1. Cleanup of existing test pods
+     * 2. Creation of new test pod
+     * 3. Monitoring pod until running state
+     * 4. Verification of pod logs
+     * 5. Pod deletion and termination verification
+     *
+     * Note: Test timeout is set to 120 seconds to accommodate all operations via vitest.config.ts
+     */
+    test("pod lifecycle management", async () => {
+        const podBaseName = "unit-test";
+        const podName = `${podBaseName}-${generateRandomSHA()}`;
+        // Step 1: Check if pods with unit-test prefix exist and terminate them if found
+        const existingPods = await client.request({
             method: "tools/call",
             params: {
-                name: "delete_pod",
+                name: "list_pods",
                 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...");
+        }, ListPodsResponseSchema);
+        const podsResponse = JSON.parse(existingPods.content[0].text);
+        const existingTestPods = podsResponse.items?.filter((pod) => pod.metadata?.name?.startsWith(podBaseName)) || [];
+        // Terminate existing test pods if found
+        for (const pod of existingTestPods) {
+            await client.request({
+                method: "tools/call",
+                params: {
+                    name: "delete_pod",
+                    arguments: {
+                        name: pod.metadata.name,
+                        namespace: "default",
+                        ignoreNotFound: true,
+                    },
+                },
+            }, DeletePodResponseSchema);
+            // Wait for pod to be fully terminated
+            let podDeleted = false;
+            const terminationStartTime = Date.now();
+            while (!podDeleted && Date.now() - terminationStartTime < 10000) {
+                try {
+                    await client.request({
+                        method: "tools/call",
+                        params: {
+                            name: "describe_pod",
+                            arguments: {
+                                name: pod.metadata.name,
+                                namespace: "default",
+                            },
+                        },
+                    }, ListPodsResponseSchema);
+                    await sleep(500);
+                }
+                catch (error) {
+                    // If we get an error, it might be because the pod is gone (404)
+                    podDeleted = true;
+                }
+            }
+        }
+        // Create new pod with random SHA name
         const createPodResult = await client.request({
             method: "tools/call",
             params: {
                 name: "create_pod",
                 arguments: {
-                    // Changed from input to arguments
-                    name: "test-pod",
+                    name: podName,
                     namespace: "default",
-                    template: "nginx",
+                    template: "busybox",
+                    command: [
+                        "/bin/sh",
+                        "-c",
+                        "echo Pod is running && sleep infinity",
+                    ],
                 },
             },
         }, 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");
-        // Describe the pod
-        console.log("Describing test pod...");
-        const describePodResult = await client.request({
-            method: "tools/call",
-            params: {
-                name: "describe_pod",
-                arguments: {
-                    name: "test-pod",
-                    namespace: "default",
+        const podResult = JSON.parse(createPodResult.content[0].text);
+        expect(podResult.podName).toBe(podName);
+        // Step 2: Wait for Running state (up to 60 seconds)
+        let podRunning = false;
+        const startTime = Date.now();
+        while (!podRunning && Date.now() - startTime < 60000) {
+            const podStatus = await client.request({
+                method: "tools/call",
+                params: {
+                    name: "describe_pod",
+                    arguments: {
+                        name: podName,
+                        namespace: "default",
+                    },
                 },
-            },
-        }, CreatePodResponseSchema // Reusing existing schema since response format is similar
-        );
-        expect(describePodResult.content[0].type).toBe("text");
-        const podDescription = JSON.parse(describePodResult.content[0].text);
-        expect(podDescription.metadata.name).toBe("test-pod");
-        expect(podDescription.metadata.namespace).toBe("default");
-        expect(podDescription.kind).toBe("Pod");
-        // 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({
+            }, ListPodsResponseSchema);
+            const status = JSON.parse(podStatus.content[0].text);
+            if (status.status?.phase === "Running") {
+                podRunning = true;
+                console.log(`Pod ${podName} is running. Checking logs...`);
+                // Check pod logs once running
+                const logsResult = await client.request({
+                    method: "tools/call",
+                    params: {
+                        name: "get_logs",
+                        arguments: {
+                            resourceType: "pod",
+                            name: podName,
+                            namespace: "default",
+                        },
+                    },
+                }, ListPodsResponseSchema);
+                expect(logsResult.content[0].type).toBe("text");
+                const logs = JSON.parse(logsResult.content[0].text);
+                expect(logs.logs[podName]).toContain("Pod is running");
+                break;
+            }
+            await sleep(1000);
+        }
+        expect(podRunning).toBe(true);
+        // Step 3: Terminate pod and verify termination (wait up to 10 seconds)
+        const deletePodResult = await client.request({
             method: "tools/call",
             params: {
-                name: "list_pods",
+                name: "delete_pod",
                 arguments: {
-                    // Changed from input to arguments
+                    name: podName,
                     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
-    }
+        }, DeletePodResponseSchema);
+        expect(deletePodResult.content[0].type).toBe("text");
+        const deleteResult = JSON.parse(deletePodResult.content[0].text);
+        expect(deleteResult.status).toBe("deleted");
+        // Try to verify pod termination, but don't fail the test if we can't confirm it
+        try {
+            let podTerminated = false;
+            const terminationStartTime = Date.now();
+            while (!podTerminated && Date.now() - terminationStartTime < 10000) {
+                try {
+                    const podStatus = await client.request({
+                        method: "tools/call",
+                        params: {
+                            name: "describe_pod",
+                            arguments: {
+                                name: podName,
+                                namespace: "default",
+                            },
+                        },
+                    }, ListPodsResponseSchema);
+                    // Pod still exists, check if it's in Terminating state
+                    const status = JSON.parse(podStatus.content[0].text);
+                    if (status.status?.phase === "Terminating") {
+                        podTerminated = true;
+                        break;
+                    }
+                    await sleep(500);
+                }
+                catch (error) {
+                    // If we get an error (404), the pod is gone which also means it's terminated
+                    podTerminated = true;
+                    break;
+                }
+            }
+            // Log termination status but don't fail the test
+            if (podTerminated) {
+                console.log(`Pod ${podName} termination confirmed`);
+            }
+            else {
+                console.log(`Pod ${podName} termination could not be confirmed within timeout, but deletion was initiated`);
+            }
+        }
+        catch (error) {
+            // 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.3",
+  "version": "0.1.5",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,7 @@
     "build": "tsc && shx chmod +x dist/*.js",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
-    "test": "vitest --testTimeout=20000",
+    "test": "vitest run",
     "prepublishOnly": "npm run build",
     "dockerbuild": "docker buildx build -t flux159/mcp-server-kubernetes --platform linux/amd64,linux/arm64 --push ."
   },
@@ -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",