mcp-server-kubernetes 1.6.2 → 2.1.0

package/dist/tools/kubectl-describe.js

@@ -0,0 +1,96 @@
+import { execSync } from "child_process";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const kubectlDescribeSchema = {
+    name: "kubectl_describe",
+    description: "Describe Kubernetes resources by resource type, name, and optionally namespace",
+    inputSchema: {
+        type: "object",
+        properties: {
+            resourceType: {
+                type: "string",
+                description: "Type of resource to describe (e.g., pods, deployments, services, etc.)"
+            },
+            name: {
+                type: "string",
+                description: "Name of the resource to describe"
+            },
+            namespace: {
+                type: "string",
+                description: "Namespace of the resource (optional - defaults to 'default' for namespaced resources)",
+                default: "default"
+            },
+            allNamespaces: {
+                type: "boolean",
+                description: "If true, describe resources across all namespaces",
+                default: false
+            }
+        },
+        required: ["resourceType", "name"],
+    },
+};
+export async function kubectlDescribe(k8sManager, input) {
+    try {
+        const resourceType = input.resourceType.toLowerCase();
+        const name = input.name;
+        const namespace = input.namespace || "default";
+        const allNamespaces = input.allNamespaces || false;
+        // Build the kubectl command
+        let command = "kubectl describe ";
+        // Add resource type
+        command += resourceType;
+        // Add name
+        command += ` ${name}`;
+        // Add namespace flag unless all namespaces is specified
+        if (allNamespaces) {
+            command += " --all-namespaces";
+        }
+        else if (namespace && !isNonNamespacedResource(resourceType)) {
+            command += ` -n ${namespace}`;
+        }
+        // Execute the command
+        try {
+            const result = execSync(command, { encoding: "utf8" });
+            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 ${resourceType}/${name} not found`,
+                                status: "not_found",
+                            }, null, 2),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            throw new McpError(ErrorCode.InternalError, `Failed to describe resource: ${error.message}`);
+        }
+    }
+    catch (error) {
+        throw new McpError(ErrorCode.InternalError, `Failed to execute kubectl describe 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());
+}

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

@@ -0,0 +1,71 @@
+import { KubernetesManager } from "../types.js";
+export declare const kubectlGenericSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            command: {
+                type: string;
+                description: string;
+            };
+            subCommand: {
+                type: string;
+                description: string;
+                optional: boolean;
+            };
+            resourceType: {
+                type: string;
+                description: string;
+                optional: boolean;
+            };
+            name: {
+                type: string;
+                description: string;
+                optional: boolean;
+            };
+            namespace: {
+                type: string;
+                description: string;
+                default: string;
+                optional: boolean;
+            };
+            outputFormat: {
+                type: string;
+                description: string;
+                enum: string[];
+                optional: boolean;
+            };
+            flags: {
+                type: string;
+                description: string;
+                optional: boolean;
+                additionalProperties: boolean;
+            };
+            args: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+                optional: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function kubectlGeneric(k8sManager: KubernetesManager, input: {
+    command: string;
+    subCommand?: string;
+    resourceType?: string;
+    name?: string;
+    namespace?: string;
+    outputFormat?: string;
+    flags?: Record<string, any>;
+    args?: string[];
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/kubectl-generic.js

@@ -0,0 +1,121 @@
+import { execSync } from "child_process";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const kubectlGenericSchema = {
+    name: "kubectl_generic",
+    description: "Execute any kubectl command with the provided arguments and flags",
+    inputSchema: {
+        type: "object",
+        properties: {
+            command: {
+                type: "string",
+                description: "The kubectl command to execute (e.g. patch, rollout, top)"
+            },
+            subCommand: {
+                type: "string",
+                description: "Subcommand if applicable (e.g. 'history' for rollout)",
+                optional: true
+            },
+            resourceType: {
+                type: "string",
+                description: "Resource type (e.g. pod, deployment)",
+                optional: true
+            },
+            name: {
+                type: "string",
+                description: "Resource name",
+                optional: true
+            },
+            namespace: {
+                type: "string",
+                description: "Namespace",
+                default: "default",
+                optional: true
+            },
+            outputFormat: {
+                type: "string",
+                description: "Output format (e.g. json, yaml, wide)",
+                enum: ["json", "yaml", "wide", "name", "custom"],
+                optional: true
+            },
+            flags: {
+                type: "object",
+                description: "Command flags as key-value pairs",
+                optional: true,
+                additionalProperties: true
+            },
+            args: {
+                type: "array",
+                items: { type: "string" },
+                description: "Additional command arguments",
+                optional: true
+            }
+        },
+        required: ["command"]
+    }
+};
+export async function kubectlGeneric(k8sManager, input) {
+    try {
+        // Start building the kubectl command
+        let cmdArgs = ["kubectl", input.command];
+        // Add subcommand if provided
+        if (input.subCommand) {
+            cmdArgs.push(input.subCommand);
+        }
+        // Add resource type if provided
+        if (input.resourceType) {
+            cmdArgs.push(input.resourceType);
+        }
+        // Add resource name if provided
+        if (input.name) {
+            cmdArgs.push(input.name);
+        }
+        // Add namespace if provided
+        if (input.namespace) {
+            cmdArgs.push(`--namespace=${input.namespace}`);
+        }
+        // Add output format if provided
+        if (input.outputFormat) {
+            cmdArgs.push(`-o=${input.outputFormat}`);
+        }
+        // Add any provided flags
+        if (input.flags) {
+            for (const [key, value] of Object.entries(input.flags)) {
+                if (value === true) {
+                    // Handle boolean flags
+                    cmdArgs.push(`--${key}`);
+                }
+                else if (value !== false && value !== null && value !== undefined) {
+                    // Skip false/null/undefined values, add others as --key=value
+                    cmdArgs.push(`--${key}=${value}`);
+                }
+            }
+        }
+        // Add any additional arguments
+        if (input.args && input.args.length > 0) {
+            cmdArgs.push(...input.args);
+        }
+        // Execute the command (join all args except the first "kubectl" which is used in execSync)
+        const command = cmdArgs.slice(1).join(' ');
+        try {
+            console.log(`Executing: kubectl ${command}`);
+            const result = execSync(`kubectl ${command}`, { encoding: "utf8" });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to execute kubectl command: ${error.message}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to execute kubectl command: ${error.message}`);
+    }
+}

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

@@ -0,0 +1,72 @@
+import { KubernetesManager } from "../types.js";
+export declare const kubectlGetSchema: {
+    readonly name: "kubectl_get";
+    readonly description: "Get or list Kubernetes resources by resource type, name, and optionally namespace";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly resourceType: {
+                readonly type: "string";
+                readonly description: "Type of resource to get (e.g., pods, deployments, services, configmaps, events, etc.)";
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Name of the resource (optional - if not provided, lists all resources of the specified type)";
+            };
+            readonly namespace: {
+                readonly type: "string";
+                readonly description: "Namespace of the resource (optional - defaults to 'default' for namespaced resources)";
+                readonly default: "default";
+            };
+            readonly output: {
+                readonly type: "string";
+                readonly enum: readonly ["json", "yaml", "wide", "name", "custom"];
+                readonly description: "Output format";
+                readonly default: "json";
+            };
+            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 optional: true;
+            };
+            readonly fieldSelector: {
+                readonly type: "string";
+                readonly description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')";
+                readonly optional: true;
+            };
+            readonly sortBy: {
+                readonly type: "string";
+                readonly description: "Sort events by a field (default: lastTimestamp). Only applicable for events.";
+                readonly optional: true;
+            };
+        };
+        readonly required: readonly ["resourceType"];
+    };
+};
+export declare function kubectlGet(k8sManager: KubernetesManager, input: {
+    resourceType: string;
+    name?: string;
+    namespace?: string;
+    output?: string;
+    allNamespaces?: boolean;
+    labelSelector?: string;
+    fieldSelector?: string;
+    sortBy?: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/tools/kubectl-get.js

@@ -0,0 +1,251 @@
+import { execSync } from "child_process";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const kubectlGetSchema = {
+    name: "kubectl_get",
+    description: "Get or list Kubernetes resources by resource type, name, and optionally namespace",
+    inputSchema: {
+        type: "object",
+        properties: {
+            resourceType: {
+                type: "string",
+                description: "Type of resource to get (e.g., pods, deployments, services, configmaps, events, etc.)"
+            },
+            name: {
+                type: "string",
+                description: "Name of the resource (optional - if not provided, lists all resources of the specified type)"
+            },
+            namespace: {
+                type: "string",
+                description: "Namespace of the resource (optional - defaults to 'default' for namespaced resources)",
+                default: "default"
+            },
+            output: {
+                type: "string",
+                enum: ["json", "yaml", "wide", "name", "custom"],
+                description: "Output format",
+                default: "json"
+            },
+            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')",
+                optional: true
+            },
+            fieldSelector: {
+                type: "string",
+                description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')",
+                optional: true
+            },
+            sortBy: {
+                type: "string",
+                description: "Sort events by a field (default: lastTimestamp). Only applicable for events.",
+                optional: true
+            }
+        },
+        required: ["resourceType"],
+    },
+};
+export async function kubectlGet(k8sManager, input) {
+    try {
+        const resourceType = input.resourceType.toLowerCase();
+        const name = input.name || "";
+        const namespace = input.namespace || "default";
+        const output = input.output || "json";
+        const allNamespaces = input.allNamespaces || false;
+        const labelSelector = input.labelSelector || "";
+        const fieldSelector = input.fieldSelector || "";
+        const sortBy = input.sortBy;
+        // Build the kubectl command
+        let command = "kubectl get ";
+        // Add resource type
+        command += resourceType;
+        // Add name if provided
+        if (name) {
+            command += ` ${name}`;
+        }
+        // For events, default to all namespaces unless explicitly specified
+        const shouldShowAllNamespaces = resourceType === "events" ?
+            (input.namespace ? false : true) : allNamespaces;
+        // Add namespace flag unless all namespaces is specified
+        if (shouldShowAllNamespaces) {
+            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 sort-by for events
+        if (resourceType === "events" && sortBy) {
+            command += ` --sort-by=.${sortBy}`;
+        }
+        else if (resourceType === "events") {
+            command += ` --sort-by=.lastTimestamp`;
+        }
+        // Add output format
+        if (output === "json") {
+            command += " -o json";
+        }
+        else if (output === "yaml") {
+            command += " -o yaml";
+        }
+        else if (output === "wide") {
+            command += " -o wide";
+        }
+        else if (output === "name") {
+            command += " -o name";
+        }
+        else if (output === "custom") {
+            if (resourceType === "events") {
+                command += ` -o 'custom-columns=LAST SEEN:.lastTimestamp,TYPE:.type,REASON:.reason,OBJECT:.involvedObject.kind/.involvedObject.name,MESSAGE:.message'`;
+            }
+            else {
+                command += ` -o 'custom-columns=NAME:.metadata.name,NAMESPACE:.metadata.namespace,STATUS:.status.phase,AGE:.metadata.creationTimestamp'`;
+            }
+        }
+        // Execute the command
+        try {
+            const result = execSync(command, { encoding: "utf8" });
+            // Format the results for better readability
+            const isListOperation = !name;
+            if (isListOperation && output === "json") {
+                try {
+                    // Parse JSON and extract key information
+                    const parsed = JSON.parse(result);
+                    if (parsed.kind && parsed.kind.endsWith("List") && parsed.items) {
+                        if (resourceType === "events") {
+                            const formattedEvents = parsed.items.map((event) => ({
+                                type: event.type || "",
+                                reason: event.reason || "",
+                                message: event.message || "",
+                                involvedObject: {
+                                    kind: event.involvedObject?.kind || "",
+                                    name: event.involvedObject?.name || "",
+                                    namespace: event.involvedObject?.namespace || "",
+                                },
+                                firstTimestamp: event.firstTimestamp || "",
+                                lastTimestamp: event.lastTimestamp || "",
+                                count: event.count || 0,
+                            }));
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify({ events: formattedEvents }, null, 2),
+                                    },
+                                ],
+                            };
+                        }
+                        else {
+                            const items = parsed.items.map((item) => ({
+                                name: item.metadata?.name || "",
+                                namespace: item.metadata?.namespace || "",
+                                kind: item.kind || resourceType,
+                                status: getResourceStatus(item),
+                                createdAt: item.metadata?.creationTimestamp
+                            }));
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify({ items }, null, 2),
+                                    },
+                                ],
+                            };
+                        }
+                    }
+                }
+                catch (parseError) {
+                    // If JSON parsing fails, return the raw output
+                    console.error("Error parsing JSON:", parseError);
+                }
+            }
+            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 ${resourceType}${name ? `/${name}` : ""} not found`,
+                                status: "not_found",
+                            }, null, 2),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            throw new McpError(ErrorCode.InternalError, `Failed to get resource: ${error.message}`);
+        }
+    }
+    catch (error) {
+        throw new McpError(ErrorCode.InternalError, `Failed to execute kubectl get command: ${error.message}`);
+    }
+}
+// Extract status from various resource types
+function getResourceStatus(resource) {
+    if (!resource)
+        return "Unknown";
+    // Pod status
+    if (resource.status?.phase) {
+        return resource.status.phase;
+    }
+    // Deployment, ReplicaSet, StatefulSet status
+    if (resource.status?.readyReplicas !== undefined) {
+        const ready = resource.status.readyReplicas || 0;
+        const total = resource.status.replicas || 0;
+        return `${ready}/${total} ready`;
+    }
+    // Service status
+    if (resource.spec?.type) {
+        return resource.spec.type;
+    }
+    // Node status
+    if (resource.status?.conditions) {
+        const readyCondition = resource.status.conditions.find((c) => c.type === "Ready");
+        if (readyCondition) {
+            return readyCondition.status === "True" ? "Ready" : "NotReady";
+        }
+    }
+    // Job/CronJob status
+    if (resource.status?.succeeded !== undefined) {
+        return resource.status.succeeded ? "Completed" : "Running";
+    }
+    // PV/PVC status
+    if (resource.status?.phase) {
+        return resource.status.phase;
+    }
+    return "Active";
+}
+// 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());
+}

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

@@ -0,0 +1,61 @@
+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 optional: true;
+            };
+            readonly fieldSelector: {
+                readonly type: "string";
+                readonly description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')";
+                readonly optional: true;
+            };
+        };
+        readonly required: readonly ["resourceType"];
+    };
+};
+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;
+}>;