mcp-server-kubernetes 2.4.1 → 2.4.3

package/README.md

@@ -17,7 +17,6 @@ https://github.com/user-attachments/assets/f25f8f4e-4d04-479b-9ae0-5dac452dd2ed
 
 <a href="https://glama.ai/mcp/servers/w71ieamqrt"><img width="380" height="200" src="https://glama.ai/mcp/servers/w71ieamqrt/badge" /></a>
 
-
 ## Usage with Claude Desktop
 
 ```json
@@ -72,7 +71,7 @@ npx mcp-chat --config "%APPDATA%\Claude\claude_desktop_config.json"
 - [x] Unified kubectl API for managing resources
   - Get or list resources with `kubectl_get`
   - Describe resources with `kubectl_describe`
-  - List resources with `kubectl_list`
+  - List resources with `kubectl_get`
   - Create resources with `kubectl_create`
   - Apply YAML manifests with `kubectl_apply`
   - Delete resources with `kubectl_delete`
@@ -84,14 +83,26 @@ npx mcp-chat --config "%APPDATA%\Claude\claude_desktop_config.json"
   - Update field(s) of a resource with `kubectl_patch`
   - Manage deployment rollouts with `kubectl_rollout`
   - Execute any kubectl command with `kubectl_generic`
+  - Verify connection with `ping`
 - [x] Advanced operations
   - Scale deployments with `kubectl_scale` (replaces legacy `scale_deployment`)
   - Port forward to pods and services with `port_forward`
   - Run Helm operations
     - Install, upgrade, and uninstall charts
     - Support for custom values, repositories, and versions
+- [x] Troubleshooting Prompt (`k8s-diagnose`)
+  - Guides through a systematic Kubernetes troubleshooting flow for pods based on a keyword and optional namespace.
 - [x] Non-destructive mode for read and create/update-only access to clusters
 
+## Prompts
+
+The MCP Kubernetes server includes specialized prompts to assist with common diagnostic operations.
+
+### k8s-diagnose Prompt
+
+This prompt provides a systematic troubleshooting flow for Kubernetes pods. It accepts a `keyword` to identify relevant pods and an optional `namespace` to narrow the search.
+The prompt's output will guide you through an autonomous troubleshooting flow, providing instructions for identifying issues, collecting evidence, and suggesting remediation steps.
+
 ## Local Development
 
 Make sure that you have [bun installed](https://bun.sh/docs/installation). Clone the repo & install dependencies:
@@ -182,7 +193,7 @@ For Claude Desktop configuration with non-destructive mode:
 
 All read-only and resource creation/update operations remain available:
 
-- Resource Information: `kubectl_get`, `kubectl_describe`, `kubectl_list`, `kubectl_logs`, `explain_resource`, `list_api_resources`
+- Resource Information: `kubectl_get`, `kubectl_describe`, `kubectl_logs`, `explain_resource`, `list_api_resources`
 - Resource Creation/Modification: `kubectl_apply`, `kubectl_create`, `kubectl_scale`, `kubectl_patch`, `kubectl_rollout`
 - Helm Operations: `install_helm_chart`, `upgrade_helm_chart`
 - Connectivity: `port_forward`, `stop_port_forward`

package/dist/config/container-templates.d.ts

@@ -61,8 +61,8 @@ export declare const CustomContainerConfig: z.ZodObject<{
         limits?: Record<string, string> | undefined;
         requests?: Record<string, string> | undefined;
     } | undefined;
-    args?: string[] | undefined;
     command?: string[] | undefined;
+    args?: string[] | undefined;
     ports?: {
         containerPort: number;
         name?: string | undefined;
@@ -84,8 +84,8 @@ export declare const CustomContainerConfig: z.ZodObject<{
         limits?: Record<string, string> | undefined;
         requests?: Record<string, string> | undefined;
     } | undefined;
-    args?: string[] | undefined;
     command?: string[] | undefined;
+    args?: string[] | undefined;
     ports?: {
         containerPort: number;
         name?: string | undefined;

package/dist/index.d.ts

@@ -296,43 +296,6 @@ declare const allTools: ({
         };
         readonly required: readonly ["resourceType", "name"];
     };
-} | {
-    readonly name: "kubectl_list";
-    readonly description: "List Kubernetes resources by resource type and optionally namespace";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly resourceType: {
-                readonly type: "string";
-                readonly description: "Type of resource to list (e.g., pods, deployments, services, configmaps, etc.)";
-            };
-            readonly namespace: {
-                readonly type: "string";
-                readonly description: "Namespace of the resources (optional - defaults to 'default' for namespaced resources)";
-                readonly default: "default";
-            };
-            readonly output: {
-                readonly type: "string";
-                readonly enum: readonly ["json", "yaml", "wide", "name", "custom", "formatted"];
-                readonly description: "Output format - 'formatted' uses a resource-specific format with key information";
-                readonly default: "formatted";
-            };
-            readonly allNamespaces: {
-                readonly type: "boolean";
-                readonly description: "If true, list resources across all namespaces";
-                readonly default: false;
-            };
-            readonly labelSelector: {
-                readonly type: "string";
-                readonly description: "Filter resources by label selector (e.g. 'app=nginx')";
-            };
-            readonly fieldSelector: {
-                readonly type: "string";
-                readonly description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')";
-            };
-        };
-        readonly required: readonly ["resourceType", "namespace"];
-    };
 } | {
     readonly name: "kubectl_apply";
     readonly description: "Apply a Kubernetes YAML manifest from a string or file";
@@ -591,5 +554,13 @@ declare const allTools: ({
         };
         readonly required: readonly ["resourceType", "name", "namespace"];
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {};
+        required: never[];
+    };
 })[];
 export { allTools, destructiveTools };

package/dist/index.js

@@ -3,6 +3,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { installHelmChart, installHelmChartSchema, upgradeHelmChart, upgradeHelmChartSchema, uninstallHelmChart, uninstallHelmChartSchema, } from "./tools/helm-operations.js";
 import { explainResource, explainResourceSchema, listApiResources, listApiResourcesSchema, } from "./tools/kubectl-operations.js";
+import { execInPod, execInPodSchema } from "./tools/exec_in_pod.js";
 import { getResourceHandlers } from "./resources/handlers.js";
 import { ListResourcesRequestSchema, ReadResourceRequestSchema, ListToolsRequestSchema, CallToolRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import { KubernetesManager } from "./types.js";
@@ -14,7 +15,6 @@ import { kubectlScale, kubectlScaleSchema } from "./tools/kubectl-scale.js";
 import { kubectlContext, kubectlContextSchema, } from "./tools/kubectl-context.js";
 import { kubectlGet, kubectlGetSchema } from "./tools/kubectl-get.js";
 import { kubectlDescribe, kubectlDescribeSchema, } from "./tools/kubectl-describe.js";
-import { kubectlList, kubectlListSchema } from "./tools/kubectl-list.js";
 import { kubectlApply, kubectlApplySchema } from "./tools/kubectl-apply.js";
 import { kubectlDelete, kubectlDeleteSchema } from "./tools/kubectl-delete.js";
 import { kubectlCreate, kubectlCreateSchema } from "./tools/kubectl-create.js";
@@ -22,6 +22,8 @@ import { kubectlLogs, kubectlLogsSchema } from "./tools/kubectl-logs.js";
 import { kubectlGeneric, kubectlGenericSchema, } from "./tools/kubectl-generic.js";
 import { kubectlPatch, kubectlPatchSchema } from "./tools/kubectl-patch.js";
 import { kubectlRollout, kubectlRolloutSchema, } from "./tools/kubectl-rollout.js";
+import { registerPromptHandlers } from "./prompts/index.js";
+import { ping, pingSchema } from "./tools/ping.js";
 // Check if non-destructive tools only mode is enabled
 const nonDestructiveTools = process.env.ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS === "true";
 // Define destructive tools (delete and uninstall operations)
@@ -38,7 +40,6 @@ const allTools = [
     // Unified kubectl-style tools - these replace many specific tools
     kubectlGetSchema,
     kubectlDescribeSchema,
-    kubectlListSchema,
     kubectlApplySchema,
     kubectlDeleteSchema,
     kubectlCreateSchema,
@@ -57,20 +58,31 @@ const allTools = [
     // Port forwarding
     PortForwardSchema,
     StopPortForwardSchema,
+    execInPodSchema,
     // API resource operations
     listApiResourcesSchema,
     // Generic kubectl command
     kubectlGenericSchema,
+    // Ping utility
+    pingSchema,
 ];
 const k8sManager = new KubernetesManager();
 const server = new Server({
     name: serverConfig.name,
     version: serverConfig.version,
-}, serverConfig);
+}, {
+    ...serverConfig,
+    capabilities: {
+        prompts: {},
+        ...serverConfig.capabilities,
+    },
+});
 // Resources handlers
 const resourceHandlers = getResourceHandlers(k8sManager);
 server.setRequestHandler(ListResourcesRequestSchema, resourceHandlers.listResources);
 server.setRequestHandler(ReadResourceRequestSchema, resourceHandlers.readResource);
+// Register prompt handlers
+registerPromptHandlers(server, k8sManager);
 // Tools handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     // Filter out destructive tools if ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS is set to 'true'
@@ -92,9 +104,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (name === "kubectl_describe") {
             return await kubectlDescribe(k8sManager, input);
         }
-        if (name === "kubectl_list") {
-            return await kubectlList(k8sManager, input);
-        }
         if (name === "kubectl_apply") {
             return await kubectlApply(k8sManager, input);
         }
@@ -165,6 +174,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "kubectl_scale": {
                 return await kubectlScale(k8sManager, input);
             }
+            case "ping": {
+                return await ping();
+            }
+            case "exec_in_pod": {
+                return await execInPod(k8sManager, input);
+            }
             default:
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
         }

package/dist/models/response-schemas.d.ts

@@ -664,3 +664,25 @@ export declare const DescribeNodeResponseSchema: z.ZodObject<{
         text: string;
     }[];
 }>;
+export declare const ExecInPodResponseSchema: 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;
+    }[];
+}>;

package/dist/models/response-schemas.js

@@ -116,3 +116,6 @@ export const SetCurrentContextResponseSchema = z.object({
 export const DescribeNodeResponseSchema = z.object({
     content: z.array(ToolResponseContent),
 });
+export const ExecInPodResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});

package/dist/models/tool-models.d.ts

@@ -39,4 +39,5 @@ export declare const ListToolsResponseSchema: z.ZodObject<{
         inputSchema: Record<string, any>;
     }[];
 }>;
+export declare const PingResponseSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 export type K8sTool = z.infer<typeof ToolSchema>;

package/dist/models/tool-models.js

@@ -8,3 +8,4 @@ export const ToolSchema = z.object({
 export const ListToolsResponseSchema = z.object({
     tools: z.array(ToolSchema),
 });
+export const PingResponseSchema = z.object({});

package/dist/prompts/index.d.ts

@@ -0,0 +1,3 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { KubernetesManager } from "../types.js";
+export declare function registerPromptHandlers(server: Server, k8sManager: KubernetesManager): void;

package/dist/prompts/index.js

@@ -0,0 +1,108 @@
+import { ListPromptsRequestSchema, GetPromptRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+export function registerPromptHandlers(server, k8sManager) {
+    // Register prompts list handler
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return {
+            prompts: [
+                {
+                    name: "k8s-diagnose",
+                    description: "Diagnose Kubernetes Resources.",
+                    arguments: [
+                        {
+                            name: "keyword",
+                            description: "A keyword to search pod/node names.",
+                            required: true,
+                        },
+                        {
+                            name: "namespace",
+                            description: "Optional: Specify a namespace to narrow down the search.",
+                            required: false,
+                            default: "all"
+                        },
+                    ],
+                },
+            ],
+        };
+    });
+    // Register prompt handler
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        if (name === "k8s-diagnose") {
+            const keyword = args?.keyword;
+            const namespace = args?.namespace;
+            if (!keyword) {
+                throw new Error("Keyword parameter is required for k8s-diagnose prompt");
+            }
+            const actualNamespace = namespace || "all";
+            const message = `Diagnose Kubernetes resources (pods, nodes, etc.) containing keyword "${keyword}" in their names within namespace "${actualNamespace}" (or across all namespaces if specified) for this investigation:
+
+**Autonomous Kubernetes Diagnosis Flow**
+
+0. **Perform Quick Health Checks / Golden Signals Analysis**
+   - Assess latency, errors, and resource utilization. If a clear issue is identified (e.g., node not ready, network partition), streamline or deprioritize subsequent detailed steps.
+
+1. **Identify Resource Type and Scope**
+   - Determine the specific resource type (e.g., Pod, Node, Deployment, Service, Customresourcedefination) by analyzing labels, controller relationships, and initial observations.
+   - If needed we can use kubectl_explain tool to get list of resource type
+   - Note when you need customresourcedefinitions please use kubectl_explain
+
+2. **Assess Current State**
+   - Check resource status (e.g., ready state, desired vs. current replicas for deployments).
+   - Identify any non-running or unhealthy states (e.g., CrashLoopBackOff, NotReady, Pending, Evicted).
+   - Review placement and distribution patterns across nodes.
+
+3. **Analyze Operational History**
+   - Review recent events and warnings related to the resource.
+   - Check rollout history and update strategies for controllers (e.g., Deployments).
+   - Examine recent configuration changes or applied manifests.
+
+4. **Inspect Runtime Behavior**
+   - Collect logs from current and previous instances for errors or anomalies (e.g., container logs for pods, system logs for nodes).
+   - Test intra-cluster networking and DNS resolution.
+   - Verify storage mounts, secret accessibility, and configuration usage.
+
+5. **Evaluate Dependencies**
+   - Validate references to ConfigMaps, Secrets, and other dependent resources.
+   - Check associated service account permissions and RBAC rules.
+   - Confirm initContainers and sidecar containers have completed successfully or are running as expected.
+
+6. **Audit Resource Constraints**
+   - Analyze CPU, memory, and storage usage trends against defined requests and limits.
+   - Check node allocatable resources and capacity.
+   - Review pod disruption budgets and quotas affecting the resource.
+
+7. **Validate Cluster Context & Environment**
+   - Inspect node readiness, taints, and tolerations.
+   - Verify the current Kubernetes context and namespace.
+   - Confirm API server availability and connectivity.
+   - Check Kubernetes version compatibility (if applicable).
+
+8. **Compare Against Patterns**
+   - Benchmark against workload-specific best practices and known healthy configurations.
+   - Verify liveness, readiness, and startup probe configurations.
+   - Audit security context settings and network policies.
+
+---
+
+**Instructions:**
+- For each finding, clearly state the observation, its severity (e.g., \`CRITICAL\`, \`WARNING\`, \`INFO\`), and the evidence (e.g., \`kubectl output\`, error message in POD_NAME, timestamp). Also, print which object they found symptoms, e.g., error message in POD_NAME.
+- If there are more than 4 relevant resources (e.g., pods, nodes), pick up to 3 resources which are exhibiting the most severe or illustrative symptoms.
+- If there's a typo in user input and a closest matching object name exists, consider an auto-correction or suggest the correct name.
+- Summarize the root cause clearly and concisely at the end of the investigation, along with clear, actionable steps for remediation, including specific \`kubectl\` commands or configuration changes required.
+- If there is a node-level issue, thoroughly analyze it and explicitly post the findings.
+- **Keep the output crisp, to the point, professional, direct, and systematic, avoiding verbose descriptions. Focus on actionable insights for engineers.**`;
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: message,
+                        },
+                    },
+                ],
+            };
+        }
+        throw new Error(`Unknown prompt: ${name}`);
+    });
+}

package/dist/tools/exec_in_pod.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Tool: exec_in_pod
+ * Execute a command in a Kubernetes pod or container and return the output.
+ * Uses the official Kubernetes client-node Exec API for native execution.
+ * Supports both string and array command formats, and optional container targeting.
+ */
+import { KubernetesManager } from "../types.js";
+/**
+ * Schema for exec_in_pod tool.
+ * - name: Pod name
+ * - namespace: Namespace (default: "default")
+ * - command: Command to execute (string or array of args)
+ * - container: (Optional) Container name
+ */
+export declare const execInPodSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            namespace: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            command: {
+                anyOf: ({
+                    type: string;
+                    items?: undefined;
+                } | {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                })[];
+                description: string;
+            };
+            container: {
+                type: string;
+                description: string;
+                optional: boolean;
+            };
+            shell: {
+                type: string;
+                description: string;
+                optional: boolean;
+            };
+            timeout: {
+                type: string;
+                description: string;
+                optional: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+/**
+ * Execute a command in a Kubernetes pod or container using the Kubernetes client-node Exec API.
+ * Returns the stdout output as a text response.
+ * Throws McpError on failure.
+ */
+export declare function execInPod(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace?: string;
+    command: string | string[];
+    container?: string;
+    shell?: string;
+    timeout?: number;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/exec_in_pod.js

@@ -0,0 +1,161 @@
+/**
+ * Tool: exec_in_pod
+ * Execute a command in a Kubernetes pod or container and return the output.
+ * Uses the official Kubernetes client-node Exec API for native execution.
+ * Supports both string and array command formats, and optional container targeting.
+ */
+import * as k8s from "@kubernetes/client-node";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { Writable } from "stream";
+/**
+ * Schema for exec_in_pod tool.
+ * - name: Pod name
+ * - namespace: Namespace (default: "default")
+ * - command: Command to execute (string or array of args)
+ * - container: (Optional) Container name
+ */
+export const execInPodSchema = {
+    name: "exec_in_pod",
+    description: "Execute a command in a Kubernetes pod or container and return the output",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Name of the pod to execute the command in",
+            },
+            namespace: {
+                type: "string",
+                description: "Kubernetes namespace where the pod is located",
+                default: "default",
+            },
+            command: {
+                anyOf: [
+                    { type: "string" },
+                    { type: "array", items: { type: "string" } }
+                ],
+                description: "Command to execute in the pod (string or array of args)",
+            },
+            container: {
+                type: "string",
+                description: "Container name (required when pod has multiple containers)",
+                optional: true,
+            },
+            shell: {
+                type: "string",
+                description: "Shell to use for command execution (e.g. '/bin/sh', '/bin/bash'). If not provided, will use command as-is.",
+                optional: true,
+            },
+            timeout: {
+                type: "number",
+                description: "Timeout for command - 60000 milliseconds if not specified",
+                optional: true,
+            },
+        },
+        required: ["name", "command"],
+    },
+};
+/**
+ * Execute a command in a Kubernetes pod or container using the Kubernetes client-node Exec API.
+ * Returns the stdout output as a text response.
+ * Throws McpError on failure.
+ */
+export async function execInPod(k8sManager, input) {
+    const namespace = input.namespace || "default";
+    // Convert command to array of strings for the Exec API
+    let commandArr;
+    if (Array.isArray(input.command)) {
+        commandArr = input.command;
+    }
+    else {
+        // Always wrap string commands in a shell for correct parsing
+        const shell = input.shell || "/bin/sh";
+        commandArr = [shell, "-c", input.command];
+        console.log("[exec_in_pod] Using shell:", shell, "Command array:", commandArr);
+    }
+    // Prepare buffers to capture stdout and stderr
+    let stdout = "";
+    let stderr = "";
+    // Use Node.js Writable streams to collect output
+    const stdoutStream = new Writable({
+        write(chunk, _encoding, callback) {
+            stdout += chunk.toString();
+            callback();
+        }
+    });
+    const stderrStream = new Writable({
+        write(chunk, _encoding, callback) {
+            stderr += chunk.toString();
+            callback();
+        }
+    });
+    // Add a dummy stdin stream
+    const stdinStream = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        }
+    });
+    try {
+        // Use the Kubernetes client-node Exec API for native exec
+        const kc = k8sManager.getKubeConfig();
+        const exec = new k8s.Exec(kc);
+        // Add a timeout to avoid hanging forever if exec never returns
+        await new Promise((resolve, reject) => {
+            let finished = false;
+            const timeoutMs = input.timeout || 60000;
+            const timeout = setTimeout(() => {
+                if (!finished) {
+                    finished = true;
+                    reject(new McpError(ErrorCode.InternalError, "Exec operation timed out (possible networking, RBAC, or cluster issue)"));
+                }
+            }, timeoutMs);
+            console.log("[exec_in_pod] Calling exec.exec with params:", {
+                namespace,
+                pod: input.name,
+                container: input.container ?? "",
+                commandArr,
+                stdoutStreamType: typeof stdoutStream,
+                stderrStreamType: typeof stderrStream,
+            });
+            exec.exec(namespace, input.name, input.container ?? "", commandArr, stdoutStream, stderrStream, stdinStream, // use dummy stdin
+            true, // set tty to true
+            (status) => {
+                console.log("[exec_in_pod] exec.exec callback called. Status:", status);
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(timeout);
+                // Always resolve; handle errors based on stderr or thrown errors
+                resolve();
+            }).catch((err) => {
+                console.log("[exec_in_pod] exec.exec threw error:", err);
+                if (!finished) {
+                    finished = true;
+                    clearTimeout(timeout);
+                    reject(new McpError(ErrorCode.InternalError, `Exec threw error: ${err?.message || err}`));
+                }
+            });
+        });
+        // Return the collected stdout as the result
+        // If there is stderr output or no output at all, treat as error
+        if (stderr || (!stdout && !stderr)) {
+            throw new McpError(ErrorCode.InternalError, `Failed to execute command in pod: ${stderr || "No output"}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: stdout,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        // Collect error message and stderr output if available
+        let message = error.message || "Unknown error";
+        if (stderr) {
+            message += "\n" + stderr;
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to execute command in pod: ${message}`);
+    }
+}

package/dist/tools/kubectl-logs.js

@@ -293,12 +293,42 @@ function handleCommandError(error, resourceDescription) {
             isError: true,
         };
     }
+    // Check for multi-container pod error
+    if (error.message.includes("a container name must be specified")) {
+        // Extract pod name and available containers from error message
+        const podNameMatch = error.message.match(/for pod ([^,]+)/);
+        const containersMatch = error.message.match(/choose one of: \[([^\]]+)\]/);
+        const initContainersMatch = error.message.match(/or one of the init containers: \[([^\]]+)\]/);
+        const podName = podNameMatch ? podNameMatch[1] : 'unknown';
+        const containers = containersMatch ? containersMatch[1].split(' ').map((c) => c.trim()) : [];
+        const initContainers = initContainersMatch ? initContainersMatch[1].split(' ').map((c) => c.trim()) : [];
+        // Generate structured context for the MCP client to make decisions
+        const context = {
+            error: "Multi-container pod requires container specification",
+            status: "multi_container_error",
+            pod_name: podName,
+            available_containers: containers,
+            init_containers: initContainers,
+            suggestion: `Please specify a container name using the 'container' parameter. Available containers: ${containers.join(', ')}${initContainers.length > 0 ? `. Init containers: ${initContainers.join(', ')}` : ''}`
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(context, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
     return {
         content: [
             {
                 type: "text",
                 text: JSON.stringify({
                     error: `Failed to get logs for ${resourceDescription}: ${error.message}`,
+                    status: "general_error",
+                    original_error: error.message
                 }, null, 2),
             },
         ],

package/dist/tools/ping.d.ts

@@ -0,0 +1,10 @@
+export declare const pingSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {};
+        required: never[];
+    };
+};
+export declare function ping(): Promise<Record<string, never>>;

package/dist/tools/ping.js

@@ -0,0 +1,12 @@
+export const pingSchema = {
+    name: "ping",
+    description: "Verify that the counterpart is still responsive and the connection is alive.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+};
+export async function ping() {
+    return {};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "2.4.1",
+  "version": "2.4.3",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",

package/dist/tools/kubectl-list.d.ts

@@ -1,59 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const kubectlListSchema: {
-    readonly name: "kubectl_list";
-    readonly description: "List Kubernetes resources by resource type and optionally namespace";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly resourceType: {
-                readonly type: "string";
-                readonly description: "Type of resource to list (e.g., pods, deployments, services, configmaps, etc.)";
-            };
-            readonly namespace: {
-                readonly type: "string";
-                readonly description: "Namespace of the resources (optional - defaults to 'default' for namespaced resources)";
-                readonly default: "default";
-            };
-            readonly output: {
-                readonly type: "string";
-                readonly enum: readonly ["json", "yaml", "wide", "name", "custom", "formatted"];
-                readonly description: "Output format - 'formatted' uses a resource-specific format with key information";
-                readonly default: "formatted";
-            };
-            readonly allNamespaces: {
-                readonly type: "boolean";
-                readonly description: "If true, list resources across all namespaces";
-                readonly default: false;
-            };
-            readonly labelSelector: {
-                readonly type: "string";
-                readonly description: "Filter resources by label selector (e.g. 'app=nginx')";
-            };
-            readonly fieldSelector: {
-                readonly type: "string";
-                readonly description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')";
-            };
-        };
-        readonly required: readonly ["resourceType", "namespace"];
-    };
-};
-export declare function kubectlList(k8sManager: KubernetesManager, input: {
-    resourceType: string;
-    namespace?: string;
-    output?: string;
-    allNamespaces?: boolean;
-    labelSelector?: string;
-    fieldSelector?: string;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError?: undefined;
-} | {
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-}>;

package/dist/tools/kubectl-list.js

@@ -1,187 +0,0 @@
-import { kubectlGet } from "./kubectl-get.js";
-import { execSync } from "child_process";
-import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
-export const kubectlListSchema = {
-    name: "kubectl_list",
-    description: "List Kubernetes resources by resource type and optionally namespace",
-    inputSchema: {
-        type: "object",
-        properties: {
-            resourceType: {
-                type: "string",
-                description: "Type of resource to list (e.g., pods, deployments, services, configmaps, etc.)"
-            },
-            namespace: {
-                type: "string",
-                description: "Namespace of the resources (optional - defaults to 'default' for namespaced resources)",
-                default: "default"
-            },
-            output: {
-                type: "string",
-                enum: ["json", "yaml", "wide", "name", "custom", "formatted"],
-                description: "Output format - 'formatted' uses a resource-specific format with key information",
-                default: "formatted"
-            },
-            allNamespaces: {
-                type: "boolean",
-                description: "If true, list resources across all namespaces",
-                default: false
-            },
-            labelSelector: {
-                type: "string",
-                description: "Filter resources by label selector (e.g. 'app=nginx')"
-            },
-            fieldSelector: {
-                type: "string",
-                description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')"
-            }
-        },
-        required: ["resourceType", "namespace"],
-    },
-};
-export async function kubectlList(k8sManager, input) {
-    try {
-        const resourceType = input.resourceType.toLowerCase();
-        const namespace = input.namespace || "default";
-        const output = input.output || "formatted";
-        const allNamespaces = input.allNamespaces || false;
-        const labelSelector = input.labelSelector || "";
-        const fieldSelector = input.fieldSelector || "";
-        // If not using formatted output, delegate to kubectl_get
-        if (output !== "formatted") {
-            return await kubectlGet(k8sManager, {
-                resourceType: input.resourceType,
-                namespace: input.namespace,
-                output: input.output,
-                allNamespaces: input.allNamespaces,
-                labelSelector: input.labelSelector,
-                fieldSelector: input.fieldSelector
-            });
-        }
-        // For formatted output, we'll use resource-specific custom columns
-        let customColumns = "";
-        switch (resourceType) {
-            case "pods":
-            case "pod":
-            case "po":
-                customColumns = "NAME:.metadata.name,NAMESPACE:.metadata.namespace,STATUS:.status.phase,NODE:.spec.nodeName,IP:.status.podIP,AGE:.metadata.creationTimestamp";
-                break;
-            case "deployments":
-            case "deployment":
-            case "deploy":
-                customColumns = "NAME:.metadata.name,NAMESPACE:.metadata.namespace,READY:.status.readyReplicas/.status.replicas,UP-TO-DATE:.status.updatedReplicas,AVAILABLE:.status.availableReplicas,AGE:.metadata.creationTimestamp";
-                break;
-            case "services":
-            case "service":
-            case "svc":
-                customColumns = "NAME:.metadata.name,NAMESPACE:.metadata.namespace,TYPE:.spec.type,CLUSTER-IP:.spec.clusterIP,EXTERNAL-IP:.status.loadBalancer.ingress[0].ip,PORTS:.spec.ports[*].port,AGE:.metadata.creationTimestamp";
-                break;
-            case "nodes":
-            case "node":
-            case "no":
-                customColumns = "NAME:.metadata.name,STATUS:.status.conditions[?(@.type==\"Ready\")].status,ROLES:.metadata.labels.kubernetes\\.io/role,VERSION:.status.nodeInfo.kubeletVersion,INTERNAL-IP:.status.addresses[?(@.type==\"InternalIP\")].address,OS-IMAGE:.status.nodeInfo.osImage,KERNEL-VERSION:.status.nodeInfo.kernelVersion,CONTAINER-RUNTIME:.status.nodeInfo.containerRuntimeVersion";
-                break;
-            case "namespaces":
-            case "namespace":
-            case "ns":
-                customColumns = "NAME:.metadata.name,STATUS:.status.phase,AGE:.metadata.creationTimestamp";
-                break;
-            case "persistentvolumes":
-            case "pv":
-                customColumns = "NAME:.metadata.name,CAPACITY:.spec.capacity.storage,ACCESS_MODES:.spec.accessModes,RECLAIM_POLICY:.spec.persistentVolumeReclaimPolicy,STATUS:.status.phase,CLAIM:.spec.claimRef.name,STORAGECLASS:.spec.storageClassName,AGE:.metadata.creationTimestamp";
-                break;
-            case "persistentvolumeclaims":
-            case "pvc":
-                customColumns = "NAME:.metadata.name,NAMESPACE:.metadata.namespace,STATUS:.status.phase,VOLUME:.spec.volumeName,CAPACITY:.status.capacity.storage,ACCESS_MODES:.spec.accessModes,STORAGECLASS:.spec.storageClassName,AGE:.metadata.creationTimestamp";
-                break;
-            case "configmaps":
-            case "configmap":
-            case "cm":
-                customColumns = "NAME:.metadata.name,NAMESPACE:.metadata.namespace,DATA:.data,AGE:.metadata.creationTimestamp";
-                break;
-            case "secrets":
-            case "secret":
-                customColumns = "NAME:.metadata.name,NAMESPACE:.metadata.namespace,TYPE:.type,DATA:.data,AGE:.metadata.creationTimestamp";
-                break;
-            case "jobs":
-            case "job":
-                customColumns = "NAME:.metadata.name,NAMESPACE:.metadata.namespace,COMPLETIONS:.status.succeeded/.spec.completions,DURATION:.status.completionTime-(.status.startTime),AGE:.metadata.creationTimestamp";
-                break;
-            case "cronjobs":
-            case "cronjob":
-            case "cj":
-                customColumns = "NAME:.metadata.name,NAMESPACE:.metadata.namespace,SCHEDULE:.spec.schedule,SUSPEND:.spec.suspend,ACTIVE:.status.active,LAST_SCHEDULE:.status.lastScheduleTime,AGE:.metadata.creationTimestamp";
-                break;
-            default:
-                // For unknown resource types, fall back to a generic format
-                customColumns = "NAME:.metadata.name,NAMESPACE:.metadata.namespace,KIND:.kind,AGE:.metadata.creationTimestamp";
-                break;
-        }
-        // Build the kubectl command
-        let command = "kubectl get ";
-        // Add resource type
-        command += resourceType;
-        // Add namespace flag unless all namespaces is specified
-        if (allNamespaces) {
-            command += " --all-namespaces";
-        }
-        else if (namespace && !isNonNamespacedResource(resourceType)) {
-            command += ` -n ${namespace}`;
-        }
-        // Add label selector if provided
-        if (labelSelector) {
-            command += ` -l ${labelSelector}`;
-        }
-        // Add field selector if provided
-        if (fieldSelector) {
-            command += ` --field-selector=${fieldSelector}`;
-        }
-        // Add custom columns format
-        command += ` -o custom-columns="${customColumns}"`;
-        // Execute the command
-        try {
-            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: result,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            if (error.status === 404 || error.message.includes("not found")) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                error: `Resource type ${resourceType} not found or no resources exist`,
-                                status: "not_found",
-                            }, null, 2),
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            throw new McpError(ErrorCode.InternalError, `Failed to list resources: ${error.message}`);
-        }
-    }
-    catch (error) {
-        throw new McpError(ErrorCode.InternalError, `Failed to execute kubectl list command: ${error.message}`);
-    }
-}
-// Helper function to determine if a resource is non-namespaced
-function isNonNamespacedResource(resourceType) {
-    const nonNamespacedResources = [
-        "nodes", "node", "no",
-        "namespaces", "namespace", "ns",
-        "persistentvolumes", "pv",
-        "storageclasses", "sc",
-        "clusterroles",
-        "clusterrolebindings",
-        "customresourcedefinitions", "crd", "crds"
-    ];
-    return nonNamespacedResources.includes(resourceType.toLowerCase());
-}