mcp-server-kubernetes 1.6.2 → 2.0.0

package/dist/tools/get_events.js

@@ -1,66 +0,0 @@
-export const getEventsSchema = {
-    name: "get_events",
-    description: "Get Kubernetes events from the cluster",
-    inputSchema: {
-        type: "object",
-        properties: {
-            namespace: {
-                type: "string",
-                description: "Namespace to get events from. If not specified, gets events from all namespaces",
-            },
-            fieldSelector: {
-                type: "string",
-                description: "Field selector to filter events",
-            },
-        },
-        required: [],
-    },
-};
-export async function getEvents(k8sManager, params) {
-    const { namespace, fieldSelector } = params;
-    const api = k8sManager.getCoreApi();
-    let events;
-    if (namespace) {
-        const { body } = await api.listNamespacedEvent(namespace, undefined, // pretty
-        undefined, // allowWatchBookmarks
-        undefined, // _continue
-        undefined, // fieldSelector
-        fieldSelector // fieldSelector
-        );
-        events = body;
-    }
-    else {
-        const { body } = await api.listEventForAllNamespaces(undefined, // allowWatchBookmarks
-        undefined, // _continue
-        fieldSelector, // fieldSelector
-        undefined, // labelSelector
-        undefined, // limit
-        undefined, // pretty
-        undefined, // resourceVersion
-        undefined, // resourceVersionMatch
-        undefined // timeoutSeconds
-        );
-        events = body;
-    }
-    const formattedEvents = events.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),
-            },
-        ],
-    };
-}

package/dist/tools/get_job_logs.d.ts

@@ -1,40 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const getJobLogsSchema: {
-    readonly name: "get_job_logs";
-    readonly description: "Get logs from Pods created by a specific Job";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly name: {
-                readonly type: "string";
-                readonly description: "Name of the Job to get logs from";
-            };
-            readonly namespace: {
-                readonly type: "string";
-                readonly default: "default";
-            };
-            readonly tail: {
-                readonly type: "number";
-                readonly description: "Number of lines to return from the end of the logs";
-                readonly optional: true;
-            };
-            readonly timestamps: {
-                readonly type: "boolean";
-                readonly description: "Include timestamps in the logs";
-                readonly optional: true;
-            };
-        };
-        readonly required: readonly ["name", "namespace"];
-    };
-};
-export declare function getJobLogs(k8sManager: KubernetesManager, input: {
-    name: string;
-    namespace: string;
-    tail?: number;
-    timestamps?: boolean;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/get_job_logs.js

@@ -1,104 +0,0 @@
-export const getJobLogsSchema = {
-    name: "get_job_logs",
-    description: "Get logs from Pods created by a specific Job",
-    inputSchema: {
-        type: "object",
-        properties: {
-            name: {
-                type: "string",
-                description: "Name of the Job to get logs from",
-            },
-            namespace: {
-                type: "string",
-                default: "default",
-            },
-            tail: {
-                type: "number",
-                description: "Number of lines to return from the end of the logs",
-                optional: true,
-            },
-            timestamps: {
-                type: "boolean",
-                description: "Include timestamps in the logs",
-                optional: true,
-            },
-        },
-        required: ["name", "namespace"],
-    },
-};
-export async function getJobLogs(k8sManager, input) {
-    try {
-        const coreApi = k8sManager.getCoreApi();
-        // First, get the job to check if it exists
-        const batchApi = k8sManager.getBatchApi();
-        await batchApi.readNamespacedJob(input.name, input.namespace);
-        // Find pods associated with this job
-        const labelSelector = `job-name=${input.name}`;
-        const { body: podList } = await coreApi.listNamespacedPod(input.namespace, undefined, // pretty
-        undefined, // allowWatchBookmarks
-        undefined, // _continue
-        undefined, // fieldSelector
-        labelSelector // labelSelector
-        );
-        if (podList.items.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            message: `No pods found for job ${input.name}`,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        // Get logs from all pods belonging to this job
-        const podLogs = await Promise.all(podList.items.map(async (pod) => {
-            const podName = pod.metadata?.name || "";
-            try {
-                const logResponse = await coreApi.readNamespacedPodLog(podName, input.namespace, undefined, // container
-                undefined, // follow
-                input.timestamps || false, // timestamps
-                undefined, // sinceSeconds
-                undefined, // sinceTime
-                (input.tail != undefined ? true : true) || undefined, // tailLines
-                undefined // pretty
-                );
-                return {
-                    podName,
-                    logs: logResponse.body,
-                    status: pod.status?.phase || "Unknown",
-                    startTime: pod.status?.startTime || null,
-                };
-            }
-            catch (error) {
-                return {
-                    podName,
-                    logs: `Error retrieving logs: ${error.message || "Unknown error"}`,
-                    status: pod.status?.phase || "Unknown",
-                    startTime: pod.status?.startTime || null,
-                };
-            }
-        }));
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        job: input.name,
-                        namespace: input.namespace,
-                        pods: podLogs,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        console.error("Error getting Job logs:", {
-            status: error.response?.statusCode,
-            message: error.response?.body?.message || error.message,
-            details: error.response?.body,
-        });
-        throw error;
-    }
-}

package/dist/tools/get_logs.js

@@ -1,150 +0,0 @@
-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/list_contexts.d.ts

@@ -1,23 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const listContextsSchema: {
-    readonly name: "list_contexts";
-    readonly description: "List all available Kubernetes contexts";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly showCurrent: {
-                readonly type: "boolean";
-                readonly description: "Show which context is currently active";
-                readonly default: true;
-            };
-        };
-    };
-};
-export declare function listContexts(k8sManager: KubernetesManager, input: {
-    showCurrent?: boolean;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/list_contexts.js

@@ -1,39 +0,0 @@
-export const listContextsSchema = {
-    name: "list_contexts",
-    description: "List all available Kubernetes contexts",
-    inputSchema: {
-        type: "object",
-        properties: {
-            showCurrent: {
-                type: "boolean",
-                description: "Show which context is currently active",
-                default: true
-            }
-        }
-    },
-};
-export async function listContexts(k8sManager, input) {
-    try {
-        // Get the KubeConfig from the KubernetesManager
-        const kc = k8sManager.getKubeConfig();
-        const contexts = kc.getContexts();
-        const currentContext = input.showCurrent ? kc.getCurrentContext() : undefined;
-        const contextList = contexts.map(context => ({
-            name: context.name,
-            cluster: context.cluster,
-            user: context.user,
-            isCurrent: context.name === currentContext
-        }));
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ contexts: contextList }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to list contexts: ${error.message}`);
-    }
-}

package/dist/tools/list_cronjobs.d.ts

@@ -1,23 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const listCronJobsSchema: {
-    readonly name: "list_cronjobs";
-    readonly description: "List CronJobs in a namespace";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly namespace: {
-                readonly type: "string";
-                readonly default: "default";
-            };
-        };
-        readonly required: readonly ["namespace"];
-    };
-};
-export declare function listCronJobs(k8sManager: KubernetesManager, input: {
-    namespace?: string;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/list_cronjobs.js

@@ -1,35 +0,0 @@
-export const listCronJobsSchema = {
-    name: "list_cronjobs",
-    description: "List CronJobs in a namespace",
-    inputSchema: {
-        type: "object",
-        properties: {
-            namespace: { type: "string", default: "default" },
-        },
-        required: ["namespace"],
-    },
-};
-export async function listCronJobs(k8sManager, input) {
-    const namespace = input.namespace || "default";
-    // Get BatchV1Api from KubernetesManager
-    const batchV1Api = k8sManager.getBatchApi();
-    // List cronjobs in the specified namespace
-    const { body } = await batchV1Api.listNamespacedCronJob(namespace);
-    // Transform cronjob data to a more readable format
-    const cronjobs = body.items.map((cronjob) => ({
-        name: cronjob.metadata?.name || "",
-        namespace: cronjob.metadata?.namespace || "",
-        schedule: cronjob.spec?.schedule || "",
-        suspend: cronjob.spec?.suspend || false,
-        lastScheduleTime: cronjob.status?.lastScheduleTime || null,
-        createdAt: cronjob.metadata?.creationTimestamp,
-    }));
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({ cronjobs }, null, 2),
-            },
-        ],
-    };
-}

package/dist/tools/list_deployments.d.ts

@@ -1,23 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const listDeploymentsSchema: {
-    readonly name: "list_deployments";
-    readonly description: "List deployments in a namespace";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly namespace: {
-                readonly type: "string";
-                readonly default: "default";
-            };
-        };
-        readonly required: readonly ["namespace"];
-    };
-};
-export declare function listDeployments(k8sManager: KubernetesManager, input: {
-    namespace?: string;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/list_deployments.js

@@ -1,30 +0,0 @@
-export const listDeploymentsSchema = {
-    name: "list_deployments",
-    description: "List deployments in a namespace",
-    inputSchema: {
-        type: "object",
-        properties: {
-            namespace: { type: "string", default: "default" },
-        },
-        required: ["namespace"],
-    },
-};
-export async function listDeployments(k8sManager, input) {
-    const namespace = input.namespace || "default";
-    const { body } = await k8sManager.getAppsApi().listNamespacedDeployment(namespace);
-    const deployments = body.items.map((deployment) => ({
-        name: deployment.metadata?.name || "",
-        namespace: deployment.metadata?.namespace || "",
-        replicas: deployment.spec?.replicas || 0,
-        availableReplicas: deployment.status?.availableReplicas || 0,
-        createdAt: deployment.metadata?.creationTimestamp,
-    }));
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({ deployments }, null, 2),
-            },
-        ],
-    };
-}

package/dist/tools/list_jobs.d.ts

@@ -1,29 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const listJobsSchema: {
-    readonly name: "list_jobs";
-    readonly description: "List Jobs in a namespace, optionally filtered by a CronJob parent";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly namespace: {
-                readonly type: "string";
-                readonly default: "default";
-            };
-            readonly cronJobName: {
-                readonly type: "string";
-                readonly description: "Optional: Filter jobs created by a specific CronJob";
-                readonly optional: true;
-            };
-        };
-        readonly required: readonly ["namespace"];
-    };
-};
-export declare function listJobs(k8sManager: KubernetesManager, input: {
-    namespace: string;
-    cronJobName?: string;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/list_jobs.js

@@ -1,77 +0,0 @@
-export const listJobsSchema = {
-    name: "list_jobs",
-    description: "List Jobs in a namespace, optionally filtered by a CronJob parent",
-    inputSchema: {
-        type: "object",
-        properties: {
-            namespace: { type: "string", default: "default" },
-            cronJobName: {
-                type: "string",
-                description: "Optional: Filter jobs created by a specific CronJob",
-                optional: true,
-            },
-        },
-        required: ["namespace"],
-    },
-};
-export async function listJobs(k8sManager, input) {
-    try {
-        const namespace = input.namespace;
-        const batchV1Api = k8sManager.getBatchApi();
-        // Set up label selector if cronJobName is provided
-        let labelSelector;
-        if (input.cronJobName) {
-            labelSelector = `cronjob-name=${input.cronJobName}`;
-        }
-        // Get jobs with optional filtering
-        const { body } = await batchV1Api.listNamespacedJob(namespace, undefined, // pretty
-        undefined, // allowWatchBookmarks
-        undefined, // _continue
-        undefined, // fieldSelector
-        labelSelector // labelSelector
-        );
-        // Sort jobs by creation time (newest first)
-        const jobs = body.items.sort((a, b) => {
-            const aTime = a.metadata?.creationTimestamp
-                ? new Date(a.metadata.creationTimestamp)
-                : new Date(0);
-            const bTime = b.metadata?.creationTimestamp
-                ? new Date(b.metadata.creationTimestamp)
-                : new Date(0);
-            return bTime.getTime() - aTime.getTime();
-        });
-        // Transform job data to a more readable format
-        const formattedJobs = jobs.map((job) => ({
-            name: job.metadata?.name || "",
-            namespace: job.metadata?.namespace || "",
-            creationTime: job.metadata?.creationTimestamp || "",
-            labels: job.metadata?.labels || {},
-            completions: job.spec?.completions || 1,
-            parallelism: job.spec?.parallelism || 1,
-            status: {
-                active: job.status?.active || 0,
-                succeeded: job.status?.succeeded || 0,
-                failed: job.status?.failed || 0,
-                completionTime: job.status?.completionTime || null,
-                startTime: job.status?.startTime || null,
-                conditions: job.status?.conditions || [],
-            },
-        }));
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ jobs: formattedJobs }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        console.error("Error listing Jobs:", {
-            status: error.response?.statusCode,
-            message: error.response?.body?.message || error.message,
-            details: error.response?.body,
-        });
-        throw error;
-    }
-}

package/dist/tools/list_nodes.d.ts

@@ -1,15 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const listNodesSchema: {
-    readonly name: "list_nodes";
-    readonly description: "List all nodes in the cluster";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {};
-    };
-};
-export declare function listNodes(k8sManager: KubernetesManager): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;