mcp-server-kubernetes 3.2.0 → 3.2.1

package/dist/tools/kubectl-get.js

@@ -168,7 +168,7 @@ export async function kubectlGet(k8sManager, input) {
                                 name: item.metadata?.name || "",
                                 namespace: item.metadata?.namespace || "",
                                 kind: item.kind || resourceType,
-                                status: getResourceStatus(item),
+                                status: getResourceStatus(item, resourceType),
                                 createdAt: item.metadata?.creationTimestamp,
                             }));
                             return {
@@ -218,13 +218,94 @@ export async function kubectlGet(k8sManager, input) {
         throw new McpError(ErrorCode.InternalError, `Failed to execute kubectl get command: ${error.message}`);
     }
 }
+// Compute pod status the same way kubectl does, by inspecting container statuses
+// Based on kubernetes/pkg/printers/internalversion/printers.go printPod()
+function getPodStatus(pod) {
+    let reason = pod.status?.phase || "Unknown";
+    if (pod.status?.reason) {
+        reason = pod.status.reason;
+    }
+    // Check init container statuses
+    const initContainerStatuses = pod.status?.initContainerStatuses || [];
+    for (let i = 0; i < initContainerStatuses.length; i++) {
+        const container = initContainerStatuses[i];
+        const terminated = container.state?.terminated;
+        const waiting = container.state?.waiting;
+        if (terminated && terminated.exitCode === 0) {
+            // Init container completed successfully, continue
+            continue;
+        }
+        if (terminated) {
+            if (terminated.reason) {
+                reason = `Init:${terminated.reason}`;
+            }
+            else if (terminated.signal) {
+                reason = `Init:Signal:${terminated.signal}`;
+            }
+            else {
+                reason = `Init:ExitCode:${terminated.exitCode}`;
+            }
+        }
+        else if (waiting && waiting.reason && waiting.reason !== "PodInitializing") {
+            reason = `Init:${waiting.reason}`;
+        }
+        else {
+            const totalInit = initContainerStatuses.length;
+            reason = `Init:${i}/${totalInit}`;
+        }
+        break;
+    }
+    // If all init containers are done, check regular container statuses
+    if (initContainerStatuses.length === 0 ||
+        !reason.startsWith("Init:")) {
+        const containerStatuses = pod.status?.containerStatuses || [];
+        let hasRunning = false;
+        for (let i = containerStatuses.length - 1; i >= 0; i--) {
+            const container = containerStatuses[i];
+            const waiting = container.state?.waiting;
+            const terminated = container.state?.terminated;
+            if (waiting && waiting.reason) {
+                reason = waiting.reason;
+            }
+            else if (terminated) {
+                if (terminated.reason) {
+                    reason = terminated.reason;
+                }
+                else if (terminated.signal) {
+                    reason = `Signal:${terminated.signal}`;
+                }
+                else {
+                    reason = `ExitCode:${terminated.exitCode}`;
+                }
+            }
+            else if (container.ready && container.state?.running) {
+                hasRunning = true;
+            }
+        }
+        // If all containers are ready and running, use the phase
+        if (hasRunning && reason === (pod.status?.phase || "Unknown")) {
+            reason = pod.status?.phase || "Running";
+        }
+    }
+    // Handle pod deletion
+    if (pod.metadata?.deletionTimestamp) {
+        reason = "Terminating";
+    }
+    return reason;
+}
 // Extract status from various resource types
-function getResourceStatus(resource) {
+function getResourceStatus(resource, resourceType) {
     if (!resource)
         return "Unknown";
-    // Pod status
-    if (resource.status?.phase) {
-        return resource.status.phase;
+    const isPod = resource.kind === "Pod" ||
+        resourceType === "pods" ||
+        resourceType === "pod" ||
+        resourceType === "po" ||
+        (resource.status?.phase !== undefined &&
+            resource.status?.containerStatuses !== undefined);
+    // Pod status - use kubectl-equivalent logic
+    if (isPod) {
+        return getPodStatus(resource);
     }
     // Deployment, ReplicaSet, StatefulSet status
     if (resource.status?.readyReplicas !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@kubernetes/client-node": "1.3.0",
-    "@modelcontextprotocol/sdk": "1.25.2",
+    "@modelcontextprotocol/sdk": "1.26.0",
     "express": "4.21.2",
     "js-yaml": "4.1.1",
     "yaml": "2.7.0",