mcp-server-kubernetes 0.1.5 → 0.2.3

package/dist/tools/create_pod.js

@@ -0,0 +1,71 @@
+import { ContainerTemplate, containerTemplates } from "../config/container-templates.js";
+export const createPodSchema = {
+    name: "create_pod",
+    description: "Create a new Kubernetes pod",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string" },
+            template: {
+                type: "string",
+                enum: ContainerTemplate.options,
+            },
+            command: {
+                type: "array",
+                items: { type: "string" },
+                optional: true,
+            },
+        },
+        required: ["name", "namespace", "template"],
+    },
+};
+export async function createPod(k8sManager, input) {
+    const templateConfig = containerTemplates[input.template];
+    const pod = {
+        apiVersion: "v1",
+        kind: "Pod",
+        metadata: {
+            name: input.name,
+            namespace: input.namespace,
+            labels: {
+                "mcp-managed": "true",
+                app: input.name,
+            },
+        },
+        spec: {
+            containers: [
+                {
+                    ...templateConfig,
+                    ...(input.command && {
+                        command: input.command,
+                        args: undefined, // Clear default args when command is overridden
+                    }),
+                },
+            ],
+        },
+    };
+    const response = await k8sManager
+        .getCoreApi()
+        .createNamespacedPod(input.namespace, pod)
+        .catch((error) => {
+        console.error("Pod creation error:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        throw error;
+    });
+    k8sManager.trackResource("Pod", input.name, input.namespace);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    podName: response.body.metadata.name,
+                    status: "created",
+                }, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/delete_pod.d.ts

@@ -0,0 +1,31 @@
+import { KubernetesManager } from "../types.js";
+export declare const deletePodSchema: {
+    readonly name: "delete_pod";
+    readonly description: "Delete a Kubernetes pod";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly namespace: {
+                readonly type: "string";
+            };
+            readonly ignoreNotFound: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+        };
+        readonly required: readonly ["name", "namespace"];
+    };
+};
+export declare function deletePod(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace: string;
+    ignoreNotFound?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/delete_pod.js

@@ -0,0 +1,45 @@
+export const deletePodSchema = {
+    name: "delete_pod",
+    description: "Delete a Kubernetes pod",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string" },
+            ignoreNotFound: { type: "boolean", default: false },
+        },
+        required: ["name", "namespace"],
+    },
+};
+export async function deletePod(k8sManager, input) {
+    try {
+        await k8sManager.getCoreApi().deleteNamespacedPod(input.name, input.namespace);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        status: "deleted",
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (input.ignoreNotFound && error.response?.statusCode === 404) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            status: "not_found",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        throw error;
+    }
+}

package/dist/tools/describe_pod.d.ts

@@ -0,0 +1,33 @@
+import { KubernetesManager } from "../types.js";
+export declare const describePodSchema: {
+    readonly name: "describe_pod";
+    readonly description: "Describe a Kubernetes pod (read details like status, containers, etc.)";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly namespace: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["name", "namespace"];
+    };
+};
+export declare function describePod(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/tools/describe_pod.js

@@ -0,0 +1,81 @@
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const describePodSchema = {
+    name: "describe_pod",
+    description: "Describe a Kubernetes pod (read details like status, containers, etc.)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string" },
+        },
+        required: ["name", "namespace"],
+    },
+};
+export async function describePod(k8sManager, input) {
+    try {
+        const { body } = await k8sManager.getCoreApi().readNamespacedPod(input.name, input.namespace);
+        if (!body) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Pod not found",
+                            status: "not_found",
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Format the pod details for better readability
+        const podDetails = {
+            kind: body.kind,
+            metadata: {
+                name: body.metadata?.name,
+                namespace: body.metadata?.namespace,
+                creationTimestamp: body.metadata?.creationTimestamp,
+                labels: body.metadata?.labels,
+            },
+            spec: {
+                containers: body.spec?.containers.map((container) => ({
+                    name: container.name,
+                    image: container.image,
+                    ports: container.ports,
+                    resources: container.resources,
+                })),
+                nodeName: body.spec?.nodeName,
+            },
+            status: {
+                phase: body.status?.phase,
+                conditions: body.status?.conditions,
+                containerStatuses: body.status?.containerStatuses,
+            },
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(podDetails, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (error.response?.statusCode === 404) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Pod not found",
+                            status: "not_found",
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to describe pod: ${error.response?.body?.message || error.message}`);
+    }
+}

package/dist/tools/get_logs.d.ts

@@ -0,0 +1,67 @@
+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";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly resourceType: {
+                readonly type: "string";
+                readonly enum: readonly ["pod", "deployment", "job"];
+                readonly description: "Type of resource to get logs from";
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Name of the resource";
+            };
+            readonly namespace: {
+                readonly type: "string";
+                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)";
+                readonly optional: true;
+            };
+            readonly tail: {
+                readonly type: "number";
+                readonly description: "Number of lines to show from end of logs";
+                readonly optional: true;
+            };
+            readonly since: {
+                readonly type: "number";
+                readonly description: "Get logs since relative time in seconds";
+                readonly optional: true;
+            };
+            readonly timestamps: {
+                readonly type: "boolean";
+                readonly description: "Include timestamps in logs";
+                readonly default: false;
+            };
+        };
+        readonly required: readonly ["resourceType"];
+    };
+};
+export declare function getLogs(k8sManager: KubernetesManager, input: {
+    resourceType: string;
+    name?: string;
+    namespace?: string;
+    labelSelector?: string;
+    container?: string;
+    tail?: number;
+    sinceSeconds?: number;
+    timestamps?: boolean;
+    pretty?: boolean;
+    follow?: false;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/get_logs.js

@@ -0,0 +1,150 @@
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const getLogsSchema = {
+    name: "get_logs",
+    description: "Get logs from pods, deployments, jobs, or resources matching a label selector",
+    inputSchema: {
+        type: "object",
+        properties: {
+            resourceType: {
+                type: "string",
+                enum: ["pod", "deployment", "job"],
+                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",
+            },
+            labelSelector: {
+                type: "string",
+                description: "Label selector to filter resources",
+                optional: true,
+            },
+            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: "number",
+                description: "Get logs since relative time in seconds",
+                optional: true,
+            },
+            timestamps: {
+                type: "boolean",
+                description: "Include timestamps in logs",
+                default: false,
+            },
+        },
+        required: ["resourceType"],
+    },
+};
+async function getPodLogs(k8sManager, podName, podNamespace, input) {
+    try {
+        const { body } = await k8sManager.getCoreApi().readNamespacedPodLog(podName, podNamespace, input.container, input.follow, undefined, // insecureSkipTLSVerifyBackend
+        undefined, // limitBytes
+        input.pretty ? "true" : "false", undefined, // previous
+        input.sinceSeconds, input.tail, input.timestamps);
+        return body;
+    }
+    catch (error) {
+        if (error.response?.statusCode === 404) {
+            throw new McpError(ErrorCode.InvalidRequest, `Pod ${podName} not found in namespace ${podNamespace}`);
+        }
+        // Log full error details
+        console.error("Full error:", {
+            statusCode: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        throw new McpError(ErrorCode.InternalError, `Failed to get logs for pod ${podName}: ${error.response?.body?.message || error.message}`);
+    }
+}
+export async function getLogs(k8sManager, input) {
+    const namespace = input.namespace || "default";
+    const logs = {};
+    try {
+        // Get logs based on resource type
+        switch (input.resourceType.toLowerCase()) {
+            case "pod": {
+                if (!input.name) {
+                    throw new McpError(ErrorCode.InvalidRequest, "Pod name is required when resourceType is 'pod'");
+                }
+                logs[input.name] = await getPodLogs(k8sManager, input.name, namespace, input);
+                break;
+            }
+            case "deployment": {
+                if (!input.name) {
+                    throw new McpError(ErrorCode.InvalidRequest, "Deployment name is required when resourceType is 'deployment'");
+                }
+                const { body: deployment } = await k8sManager
+                    .getAppsApi()
+                    .readNamespacedDeployment(input.name, namespace);
+                if (!deployment.spec?.selector?.matchLabels) {
+                    throw new McpError(ErrorCode.InvalidRequest, `Deployment ${input.name} has no selector`);
+                }
+                const selector = Object.entries(deployment.spec.selector.matchLabels)
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join(",");
+                const { body: podList } = await k8sManager
+                    .getCoreApi()
+                    .listNamespacedPod(namespace, undefined, undefined, undefined, undefined, selector);
+                for (const pod of podList.items) {
+                    if (pod.metadata?.name) {
+                        logs[pod.metadata.name] = await getPodLogs(k8sManager, pod.metadata.name, namespace, input);
+                    }
+                }
+                break;
+            }
+            case "job": {
+                if (!input.name) {
+                    throw new McpError(ErrorCode.InvalidRequest, "Job name is required when resourceType is 'job'");
+                }
+                const { body: podList } = await k8sManager
+                    .getCoreApi()
+                    .listNamespacedPod(namespace, undefined, undefined, undefined, undefined, `job-name=${input.name}`);
+                for (const pod of podList.items) {
+                    if (pod.metadata?.name) {
+                        logs[pod.metadata.name] = await getPodLogs(k8sManager, pod.metadata.name, namespace, input);
+                    }
+                }
+                break;
+            }
+            default:
+                throw new McpError(ErrorCode.InvalidRequest, `Unsupported resource type: ${input.resourceType}`);
+        }
+        // If labelSelector is provided, filter or add logs by label
+        if (input.labelSelector) {
+            const { body: labeledPods } = await k8sManager
+                .getCoreApi()
+                .listNamespacedPod(namespace, undefined, undefined, undefined, undefined, input.labelSelector);
+            for (const pod of labeledPods.items) {
+                if (pod.metadata?.name) {
+                    logs[pod.metadata.name] = await getPodLogs(k8sManager, pod.metadata.name, namespace, input);
+                }
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ logs }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (error instanceof McpError)
+            throw error;
+        throw new McpError(ErrorCode.InternalError, `Failed to get logs: ${error}`);
+    }
+}

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

@@ -0,0 +1,99 @@
+import { HelmInstallOperation, HelmOperation, HelmUpgradeOperation } from "../models/helm-models.js";
+export declare const installHelmChartSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            chart: {
+                type: string;
+                description: string;
+            };
+            repo: {
+                type: string;
+                description: string;
+            };
+            namespace: {
+                type: string;
+                description: string;
+            };
+            values: {
+                type: string;
+                description: string;
+                additionalProperties: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const upgradeHelmChartSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            chart: {
+                type: string;
+                description: string;
+            };
+            repo: {
+                type: string;
+                description: string;
+            };
+            namespace: {
+                type: string;
+                description: string;
+            };
+            values: {
+                type: string;
+                description: string;
+                additionalProperties: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const uninstallHelmChartSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            namespace: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function installHelmChart(params: HelmInstallOperation): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function upgradeHelmChart(params: HelmUpgradeOperation): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function uninstallHelmChart(params: HelmOperation): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;