mcp-server-kubernetes 0.1.2 → 0.1.4

package/README.md

@@ -35,19 +35,16 @@ If you have errors, open up a standard terminal and run `kubectl get pods` to se
 - [x] List all pods
 - [x] List all services
 - [x] List all deployments
+- [x] List all nodes
 - [x] Create a pod
 - [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)
 - [ ] 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
 
 ```bash

package/dist/index.js

@@ -19,15 +19,6 @@ class KubernetesManager {
         // 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();
@@ -41,6 +32,7 @@ class KubernetesManager {
                 console.error(`Failed to delete ${resource.kind} ${resource.name}:`, error);
             }
         }
+        // TODO: Cleanup port forwards when implemented
     }
     trackResource(kind, name, namespace) {
         this.resources.push({ kind, name, namespace, createdAt: new Date() });
@@ -83,6 +75,7 @@ class KubernetesManager {
 }
 const k8sManager = new KubernetesManager();
 // Template configurations with health checks and resource limits
+// TODO: Update create_pod to accept custom images and custom template files
 const containerTemplates = {
     ubuntu: {
         name: "main",
@@ -238,6 +231,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 },
             },
             {
+                // TODO: Add support for custom images and templates (see above in containerTemplates definition)
                 name: "create_pod",
                 description: "Create a new Kubernetes pod",
                 inputSchema: {
@@ -259,6 +253,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 },
             },
             {
+                // TODO: Support for custom deployments (see above)
                 name: "create_deployment",
                 description: "Create a new Kubernetes deployment",
                 inputSchema: {
@@ -313,6 +308,63 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {},
                 },
             },
+            {
+                name: "list_nodes",
+                description: "List all nodes in the cluster",
+                inputSchema: {
+                    type: "object",
+                    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"],
+                },
+            },
         ],
     };
 });
@@ -404,9 +456,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "create_pod": {
-                console.error("calling create_pod");
-                console.error(input);
-                console.error(request);
                 const createPodInput = input;
                 const templateConfig = containerTemplates[createPodInput.template];
                 const pod = {
@@ -426,21 +475,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),
                         },
@@ -496,7 +554,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                     type: "text",
                                     text: JSON.stringify({
                                         error: "Pod not found",
-                                        status: "not_found"
+                                        status: "not_found",
                                     }, null, 2),
                                 },
                             ],
@@ -513,7 +571,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             labels: body.metadata?.labels,
                         },
                         spec: {
-                            containers: body.spec?.containers.map(container => ({
+                            containers: body.spec?.containers.map((container) => ({
                                 name: container.name,
                                 image: container.image,
                                 ports: container.ports,
@@ -525,7 +583,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             phase: body.status?.phase,
                             conditions: body.status?.conditions,
                             containerStatuses: body.status?.containerStatuses,
-                        }
+                        },
                     };
                     return {
                         content: [
@@ -544,7 +602,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                     type: "text",
                                     text: JSON.stringify({
                                         error: "Pod not found",
-                                        status: "not_found"
+                                        status: "not_found",
                                     }, null, 2),
                                 },
                             ],
@@ -567,6 +625,119 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "list_nodes": {
+                const { body } = await k8sManager.getCoreApi().listNode();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                nodes: body.items,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            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}`);
+                }
+            }
             default:
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
         }
@@ -605,6 +776,12 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
                 mimeType: "application/json",
                 description: "List of all namespaces",
             },
+            {
+                uri: "k8s://nodes",
+                name: "Kubernetes Nodes",
+                mimeType: "application/json",
+                description: "List of all nodes in the cluster",
+            },
         ],
     };
 });
@@ -612,8 +789,11 @@ 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();
+        const isNamespaces = parts[0] === "namespaces";
+        const isNodes = parts[0] === "nodes";
+        if ((isNamespaces || isNodes) && parts.length === 1) {
+            const fn = isNodes ? "listNode" : "listNamespace";
+            const { body } = await k8sManager.getCoreApi()[fn]();
             return {
                 contents: [
                     {

package/dist/types.d.ts

@@ -229,6 +229,50 @@ export declare const ListNamespacesResponseSchema: z.ZodObject<{
         text: string;
     }[];
 }>;
+export declare const ListNodesResponseSchema: 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 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;

package/dist/types.js

@@ -70,6 +70,18 @@ export const ListNamespacesResponseSchema = z.object({
         text: z.string(),
     })),
 });
+export const ListNodesResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        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),
 });

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, 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,134 +81,209 @@ 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");
         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");
-        // Describe the pod
-        console.log("Describing test pod...");
-        const describePodResult = await client.request({
+        // List nodes
+        console.log("Listing nodes...");
+        const listNodesResult = await client.request({
             method: "tools/call",
             params: {
-                name: "describe_pod",
-                arguments: {
-                    name: "test-pod",
-                    namespace: "default",
-                },
+                name: "list_nodes",
+                arguments: {},
             },
-        }, 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({
+        }, 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: {
-                    // 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({
+        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: "list_deployments",
+                name: "create_pod",
                 arguments: {
-                    // Changed from input to arguments
+                    name: podName,
                     namespace: "default",
+                    template: "busybox",
+                    command: ["/bin/sh", "-c", "echo Pod is running && sleep infinity"],
                 },
             },
-        }, 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({
+        }, 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: "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}`);
+        }
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -19,8 +19,9 @@
     "build": "tsc && shx chmod +x dist/*.js",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
-    "test": "vitest --testTimeout=20000",
-    "prepublishOnly": "npm run build"
+    "test": "vitest run",
+    "prepublishOnly": "npm run build",
+    "dockerbuild": "docker buildx build -t flux159/mcp-server-kubernetes --platform linux/amd64,linux/arm64 --push ."
   },
   "keywords": [
     "mcp",