mcp-server-kubernetes 1.6.2 → 2.1.0

package/dist/tools/kubectl-list.js

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

package/dist/tools/{get_logs.d.ts → kubectl-logs.d.ts}

@@ -1,13 +1,13 @@
 import { KubernetesManager } from "../types.js";
-export declare const getLogsSchema: {
-    readonly name: "get_logs";
-    readonly description: "Get logs from pods, deployments, jobs, or resources matching a label selector";
+export declare const kubectlLogsSchema: {
+    readonly name: "kubectl_logs";
+    readonly description: "Get logs from Kubernetes resources like pods, deployments, or jobs";
     readonly inputSchema: {
         readonly type: "object";
         readonly properties: {
             readonly resourceType: {
                 readonly type: "string";
-                readonly enum: readonly ["pod", "deployment", "job"];
+                readonly enum: readonly ["pod", "deployment", "job", "cronjob"];
                 readonly description: "Type of resource to get logs from";
             };
             readonly name: {
@@ -19,11 +19,6 @@ export declare const getLogsSchema: {
                 readonly description: "Namespace of the resource";
                 readonly default: "default";
             };
-            readonly labelSelector: {
-                readonly type: "string";
-                readonly description: "Label selector to filter resources";
-                readonly optional: true;
-            };
             readonly container: {
                 readonly type: "string";
                 readonly description: "Container name (required when pod has multiple containers)";
@@ -35,8 +30,13 @@ export declare const getLogsSchema: {
                 readonly optional: true;
             };
             readonly since: {
-                readonly type: "number";
-                readonly description: "Get logs since relative time in seconds";
+                readonly type: "string";
+                readonly description: "Show logs since relative time (e.g. '5s', '2m', '3h')";
+                readonly optional: true;
+            };
+            readonly sinceTime: {
+                readonly type: "string";
+                readonly description: "Show logs since absolute time (RFC3339)";
                 readonly optional: true;
             };
             readonly timestamps: {
@@ -44,21 +44,37 @@ export declare const getLogsSchema: {
                 readonly description: "Include timestamps in logs";
                 readonly default: false;
             };
+            readonly previous: {
+                readonly type: "boolean";
+                readonly description: "Include logs from previously terminated containers";
+                readonly default: false;
+            };
+            readonly follow: {
+                readonly type: "boolean";
+                readonly description: "Follow logs output (not recommended, may cause timeouts)";
+                readonly default: false;
+            };
+            readonly labelSelector: {
+                readonly type: "string";
+                readonly description: "Filter resources by label selector";
+                readonly optional: true;
+            };
         };
-        readonly required: readonly ["resourceType"];
+        readonly required: readonly ["resourceType", "name", "namespace"];
     };
 };
-export declare function getLogs(k8sManager: KubernetesManager, input: {
+export declare function kubectlLogs(k8sManager: KubernetesManager, input: {
     resourceType: string;
-    name?: string;
-    namespace?: string;
-    labelSelector?: string;
+    name: string;
+    namespace: string;
     container?: string;
     tail?: number;
-    sinceSeconds?: number;
+    since?: string;
+    sinceTime?: string;
     timestamps?: boolean;
-    pretty?: boolean;
-    follow?: false;
+    previous?: boolean;
+    follow?: boolean;
+    labelSelector?: string;
 }): Promise<{
     content: {
         type: string;

package/dist/tools/kubectl-logs.js

@@ -0,0 +1,312 @@
+import { execSync } from "child_process";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const kubectlLogsSchema = {
+    name: "kubectl_logs",
+    description: "Get logs from Kubernetes resources like pods, deployments, or jobs",
+    inputSchema: {
+        type: "object",
+        properties: {
+            resourceType: {
+                type: "string",
+                enum: ["pod", "deployment", "job", "cronjob"],
+                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",
+            },
+            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: "string",
+                description: "Show logs since relative time (e.g. '5s', '2m', '3h')",
+                optional: true,
+            },
+            sinceTime: {
+                type: "string",
+                description: "Show logs since absolute time (RFC3339)",
+                optional: true,
+            },
+            timestamps: {
+                type: "boolean",
+                description: "Include timestamps in logs",
+                default: false,
+            },
+            previous: {
+                type: "boolean",
+                description: "Include logs from previously terminated containers",
+                default: false,
+            },
+            follow: {
+                type: "boolean",
+                description: "Follow logs output (not recommended, may cause timeouts)",
+                default: false,
+            },
+            labelSelector: {
+                type: "string",
+                description: "Filter resources by label selector",
+                optional: true,
+            }
+        },
+        required: ["resourceType", "name", "namespace"],
+    },
+};
+export async function kubectlLogs(k8sManager, input) {
+    try {
+        const resourceType = input.resourceType.toLowerCase();
+        const name = input.name;
+        const namespace = input.namespace || "default";
+        // Build the kubectl command base
+        let baseCommand = `kubectl -n ${namespace}`;
+        // Handle different resource types
+        if (resourceType === "pod") {
+            // Direct pod logs
+            baseCommand += ` logs ${name}`;
+            // If container is specified, add it
+            if (input.container) {
+                baseCommand += ` -c ${input.container}`;
+            }
+            // Add options
+            baseCommand = addLogOptions(baseCommand, input);
+            // Execute the command
+            try {
+                const result = execSync(baseCommand, { encoding: "utf8" });
+                return formatLogOutput(name, result);
+            }
+            catch (error) {
+                return handleCommandError(error, `pod ${name}`);
+            }
+        }
+        else if (resourceType === "deployment" || resourceType === "job" || resourceType === "cronjob") {
+            // For deployments, jobs and cronjobs we need to find the pods first
+            let selectorCommand;
+            if (resourceType === "deployment") {
+                selectorCommand = `kubectl -n ${namespace} get deployment ${name} -o jsonpath='{.spec.selector.matchLabels}'`;
+            }
+            else if (resourceType === "job") {
+                // For jobs, we use the job-name label
+                return getLabelSelectorLogs(`job-name=${name}`, namespace, input);
+            }
+            else if (resourceType === "cronjob") {
+                // For cronjobs, it's more complex - need to find the job first
+                const jobsCommand = `kubectl -n ${namespace} get jobs --selector=job-name=${name} -o jsonpath='{.items[*].metadata.name}'`;
+                try {
+                    const jobs = execSync(jobsCommand, { encoding: "utf8" }).trim().split(' ');
+                    if (jobs.length === 0 || (jobs.length === 1 && jobs[0] === '')) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        message: `No jobs found for cronjob ${name} in namespace ${namespace}`,
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    // Get logs for all jobs
+                    const allJobLogs = {};
+                    for (const job of jobs) {
+                        // Get logs for pods from this job
+                        const result = await getLabelSelectorLogs(`job-name=${job}`, namespace, input);
+                        const jobLog = JSON.parse(result.content[0].text);
+                        allJobLogs[job] = jobLog.logs;
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    cronjob: name,
+                                    namespace: namespace,
+                                    jobs: allJobLogs,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return handleCommandError(error, `cronjob ${name}`);
+                }
+            }
+            try {
+                if (resourceType === "deployment") {
+                    // Get the deployment's selector
+                    if (!selectorCommand) {
+                        throw new Error("Selector command is undefined");
+                    }
+                    const selectorJson = execSync(selectorCommand, { encoding: "utf8" }).trim();
+                    const selector = JSON.parse(selectorJson.replace(/'/g, '"'));
+                    // Convert to label selector format
+                    const labelSelector = Object.entries(selector)
+                        .map(([key, value]) => `${key}=${value}`)
+                        .join(',');
+                    return getLabelSelectorLogs(labelSelector, namespace, input);
+                }
+                // For jobs and cronjobs, the logic is handled above
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                error: `Unexpected resource type: ${resourceType}`,
+                            }, null, 2),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            catch (error) {
+                return handleCommandError(error, `${resourceType} ${name}`);
+            }
+        }
+        else if (input.labelSelector) {
+            // Handle logs by label selector
+            return getLabelSelectorLogs(input.labelSelector, namespace, input);
+        }
+        else {
+            throw new McpError(ErrorCode.InvalidRequest, `Unsupported resource type: ${resourceType}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof McpError)
+            throw error;
+        throw new McpError(ErrorCode.InternalError, `Failed to get logs: ${error.message}`);
+    }
+}
+// Helper function to add log options to the kubectl command
+function addLogOptions(baseCommand, input) {
+    let command = baseCommand;
+    // Add options based on inputs
+    if (input.tail !== undefined) {
+        command += ` --tail=${input.tail}`;
+    }
+    if (input.since) {
+        command += ` --since=${input.since}`;
+    }
+    if (input.sinceTime) {
+        command += ` --since-time=${input.sinceTime}`;
+    }
+    if (input.timestamps) {
+        command += ` --timestamps`;
+    }
+    if (input.previous) {
+        command += ` --previous`;
+    }
+    if (input.follow) {
+        command += ` --follow`;
+    }
+    return command;
+}
+// Helper function to get logs for resources selected by labels
+async function getLabelSelectorLogs(labelSelector, namespace, input) {
+    try {
+        // First, find all pods matching the label selector
+        const podsCommand = `kubectl -n ${namespace} get pods --selector=${labelSelector} -o jsonpath='{.items[*].metadata.name}'`;
+        const pods = execSync(podsCommand, { encoding: "utf8" }).trim().split(' ');
+        if (pods.length === 0 || (pods.length === 1 && pods[0] === '')) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            message: `No pods found with label selector "${labelSelector}" in namespace ${namespace}`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        // Get logs for each pod
+        const logsMap = {};
+        for (const pod of pods) {
+            // Skip empty pod names
+            if (!pod)
+                continue;
+            let podCommand = `kubectl -n ${namespace} logs ${pod}`;
+            // Add container if specified
+            if (input.container) {
+                podCommand += ` -c ${input.container}`;
+            }
+            // Add other options
+            podCommand = addLogOptions(podCommand, input);
+            try {
+                const logs = execSync(podCommand, { encoding: "utf8" });
+                logsMap[pod] = logs;
+            }
+            catch (error) {
+                logsMap[pod] = `Error: ${error.message}`;
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        selector: labelSelector,
+                        namespace: namespace,
+                        logs: logsMap,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleCommandError(error, `pods with selector "${labelSelector}"`);
+    }
+}
+// Helper function to format log output
+function formatLogOutput(resourceName, logOutput) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    name: resourceName,
+                    logs: logOutput,
+                }, null, 2),
+            },
+        ],
+    };
+}
+// Helper function to handle command errors
+function handleCommandError(error, resourceDescription) {
+    console.error(`Error getting logs for ${resourceDescription}:`, error);
+    if (error.status === 404 || error.message.includes("not found")) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: `Resource ${resourceDescription} not found`,
+                        status: "not_found",
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    error: `Failed to get logs for ${resourceDescription}: ${error.message}`,
+                }, null, 2),
+            },
+        ],
+        isError: true,
+    };
+}

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

@@ -0,0 +1,57 @@
+import { KubernetesManager } from "../types.js";
+export declare const kubectlPatchSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            resourceType: {
+                type: string;
+                description: string;
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            namespace: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            patchType: {
+                type: string;
+                description: string;
+                enum: string[];
+                default: string;
+            };
+            patchData: {
+                type: string;
+                description: string;
+            };
+            patchFile: {
+                type: string;
+                description: string;
+            };
+            dryRun: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function kubectlPatch(k8sManager: KubernetesManager, input: {
+    resourceType: string;
+    name: string;
+    namespace?: string;
+    patchType?: "strategic" | "merge" | "json";
+    patchData?: object;
+    patchFile?: string;
+    dryRun?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;