mcp-server-kubernetes 0.2.5 → 0.3.0

package/README.md

@@ -49,6 +49,7 @@ If you have errors open up a standard terminal and run `kubectl get pods` to see
   - Support for namespaces
   - Support for version specification
   - Support for custom repositories
+- [x] kubectl explain and kubectl api-resources support
 - [ ] Port forward to a pod
 - [ ] Choose namespace for next commands (memory)
 

package/dist/index.js

@@ -4,8 +4,9 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { listPods, listPodsSchema } from "./tools/list_pods.js";
 import { listNodes, listNodesSchema } from "./tools/list_nodes.js";
 import { listServices, listServicesSchema } from "./tools/list_services.js";
-import { listDeployments, listDeploymentsSchema } from "./tools/list_deployments.js";
+import { listDeployments, listDeploymentsSchema, } from "./tools/list_deployments.js";
 import { installHelmChart, installHelmChartSchema, upgradeHelmChart, upgradeHelmChartSchema, uninstallHelmChart, uninstallHelmChartSchema, } from "./tools/helm-operations.js";
+import { explainResource, explainResourceSchema, listApiResources, listApiResourcesSchema, } from "./tools/kubectl-operations.js";
 import { createPod, createPodSchema } from "./tools/create_pod.js";
 import { deletePod, deletePodSchema } from "./tools/delete_pod.js";
 import { describePod, describePodSchema } from "./tools/describe_pod.js";
@@ -40,6 +41,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             installHelmChartSchema,
             upgradeHelmChartSchema,
             uninstallHelmChartSchema,
+            explainResourceSchema,
+            listApiResourcesSchema,
         ],
     };
 });
@@ -109,6 +112,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "uninstall_helm_chart": {
                 return await uninstallHelmChart(input);
             }
+            case "explain_resource": {
+                return await explainResource(input);
+            }
+            case "list_api_resources": {
+                return await listApiResources(input);
+            }
             default:
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
         }

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const KubectlResponseSchema: 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 interface ExplainResourceParams {
+    resource: string;
+    apiVersion?: string;
+    recursive?: boolean;
+    output?: "plaintext" | "plaintext-openapiv2";
+}
+export interface ListApiResourcesParams {
+    apiGroup?: string;
+    namespaced?: boolean;
+    verbs?: string[];
+    output?: "wide" | "name" | "no-headers";
+}

package/dist/models/kubectl-models.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const KubectlResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});

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

@@ -0,0 +1,72 @@
+import { ExplainResourceParams, ListApiResourcesParams } from "../models/kubectl-models.js";
+export declare const explainResourceSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            resource: {
+                type: string;
+                description: string;
+            };
+            apiVersion: {
+                type: string;
+                description: string;
+            };
+            recursive: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            output: {
+                type: string;
+                description: string;
+                enum: string[];
+                default: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const listApiResourcesSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            apiGroup: {
+                type: string;
+                description: string;
+            };
+            namespaced: {
+                type: string;
+                description: string;
+            };
+            verbs: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            output: {
+                type: string;
+                description: string;
+                enum: string[];
+                default: string;
+            };
+        };
+    };
+};
+export declare function explainResource(params: ExplainResourceParams): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function listApiResources(params: ListApiResourcesParams): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/kubectl-operations.js

@@ -0,0 +1,124 @@
+import { execSync } from "child_process";
+export const explainResourceSchema = {
+    name: "explain_resource",
+    description: "Get documentation for a Kubernetes resource or field",
+    inputSchema: {
+        type: "object",
+        properties: {
+            resource: {
+                type: "string",
+                description: "Resource name or field path (e.g. 'pods' or 'pods.spec.containers')",
+            },
+            apiVersion: {
+                type: "string",
+                description: "API version to use (e.g. 'apps/v1')",
+            },
+            recursive: {
+                type: "boolean",
+                description: "Print the fields of fields recursively",
+                default: false,
+            },
+            output: {
+                type: "string",
+                description: "Output format (plaintext or plaintext-openapiv2)",
+                enum: ["plaintext", "plaintext-openapiv2"],
+                default: "plaintext",
+            },
+        },
+        required: ["resource"],
+    },
+};
+export const listApiResourcesSchema = {
+    name: "list_api_resources",
+    description: "List the API resources available in the cluster",
+    inputSchema: {
+        type: "object",
+        properties: {
+            apiGroup: {
+                type: "string",
+                description: "API group to filter by",
+            },
+            namespaced: {
+                type: "boolean",
+                description: "If true, only show namespaced resources",
+            },
+            verbs: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+                description: "List of verbs to filter by",
+            },
+            output: {
+                type: "string",
+                description: "Output format (wide, name, or no-headers)",
+                enum: ["wide", "name", "no-headers"],
+                default: "wide",
+            },
+        },
+    },
+};
+const executeKubectlCommand = (command) => {
+    try {
+        return execSync(command, { encoding: "utf8" });
+    }
+    catch (error) {
+        throw new Error(`Kubectl command failed: ${error.message}`);
+    }
+};
+export async function explainResource(params) {
+    try {
+        let command = "kubectl explain";
+        if (params.apiVersion) {
+            command += ` --api-version=${params.apiVersion}`;
+        }
+        if (params.recursive) {
+            command += " --recursive";
+        }
+        if (params.output) {
+            command += ` --output=${params.output}`;
+        }
+        command += ` ${params.resource}`;
+        const result = executeKubectlCommand(command);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to explain resource: ${error.message}`);
+    }
+}
+export async function listApiResources(params) {
+    try {
+        let command = "kubectl api-resources";
+        if (params.apiGroup) {
+            command += ` --api-group=${params.apiGroup}`;
+        }
+        if (params.namespaced !== undefined) {
+            command += ` --namespaced=${params.namespaced}`;
+        }
+        if (params.verbs && params.verbs.length > 0) {
+            command += ` --verbs=${params.verbs.join(",")}`;
+        }
+        if (params.output) {
+            command += ` -o ${params.output}`;
+        }
+        const result = executeKubectlCommand(command);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to list API resources: ${error.message}`);
+    }
+}

package/package.json

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