mcp-server-kubernetes 0.1.5 → 0.2.3

package/dist/helm.test.js

@@ -1,208 +0,0 @@
-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/unit.test.d.ts

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

package/dist/unit.test.js

@@ -1,293 +0,0 @@
-// 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, 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));
-}
-/**
- * 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;
-        }
-    });
-    /**
-     * 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);
-        }
-    });
-    /**
-     * 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({
-            method: "tools/list",
-        }, 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: {},
-            },
-        }, ListNamespacesResponseSchema);
-        expect(namespacesResult.content[0].type).toBe("text");
-        const namespaces = JSON.parse(namespacesResult.content[0].text);
-        expect(namespaces.namespaces).toBeDefined();
-        // List nodes
-        console.log("Listing nodes...");
-        const listNodesResult = await client.request({
-            method: "tools/call",
-            params: {
-                name: "list_nodes",
-                arguments: {},
-            },
-        }, ListNodesResponseSchema);
-        expect(listNodesResult.content[0].type).toBe("text");
-        const nodes = JSON.parse(listNodesResult.content[0].text);
-        expect(nodes.nodes).toBeDefined();
-        expect(Array.isArray(nodes.nodes)).toBe(true);
-    });
-    /**
-     * 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: "list_pods",
-                arguments: {
-                    namespace: "default",
-                },
-            },
-        }, 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: {
-                    name: podName,
-                    namespace: "default",
-                    template: "busybox",
-                    command: [
-                        "/bin/sh",
-                        "-c",
-                        "echo Pod is running && sleep infinity",
-                    ],
-                },
-            },
-        }, CreatePodResponseSchema);
-        expect(createPodResult.content[0].type).toBe("text");
-        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",
-                    },
-                },
-            }, 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: "delete_pod",
-                arguments: {
-                    name: podName,
-                    namespace: "default",
-                },
-            },
-        }, 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 });
-});