mcp-server-kubernetes 1.6.2 → 2.1.0

package/dist/tools/get_configmap.js

@@ -1,48 +0,0 @@
-export const GetConfigMapSchema = {
-    name: "get_configmap",
-    description: "Get a Kubernetes ConfigMap",
-    inputSchema: {
-        type: "object",
-        properties: {
-            name: { type: "string" },
-            namespace: { type: "string" },
-        },
-        required: ["name", "namespace"],
-    },
-};
-export async function getConfigMap(k8sManager, input) {
-    try {
-        const response = await k8sManager.getCoreApi().readNamespacedConfigMap(input.name, input.namespace);
-        if (response.body && response.body.data) {
-            return {
-                content: [
-                    {
-                        success: true,
-                        message: `Fetched ConfigMap ${input.name} in namespace ${input.namespace}`,
-                        data: response.body.data,
-                    },
-                ],
-            };
-        }
-        else {
-            return {
-                content: [
-                    {
-                        success: false,
-                        message: `ConfigMap ${input.name} in namespace ${input.namespace} not found or has no data.`,
-                    },
-                ],
-            };
-        }
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    success: false,
-                    message: `Failed to get ConfigMap ${input.name} in namespace ${input.namespace}. Error: ${error.message}`,
-                },
-            ],
-        };
-    }
-}

package/dist/tools/get_current_context.d.ts

@@ -1,23 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const getCurrentContextSchema: {
-    readonly name: "get_current_context";
-    readonly description: "Get the current Kubernetes context";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly detailed: {
-                readonly type: "boolean";
-                readonly description: "Include detailed information about the current context";
-                readonly default: false;
-            };
-        };
-    };
-};
-export declare function getCurrentContext(k8sManager: KubernetesManager, input: {
-    detailed?: boolean;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/get_current_context.js

@@ -1,55 +0,0 @@
-export const getCurrentContextSchema = {
-    name: "get_current_context",
-    description: "Get the current Kubernetes context",
-    inputSchema: {
-        type: "object",
-        properties: {
-            detailed: {
-                type: "boolean",
-                description: "Include detailed information about the current context",
-                default: false
-            }
-        }
-    },
-};
-export async function getCurrentContext(k8sManager, input) {
-    try {
-        // Get the KubeConfig from the KubernetesManager
-        const kc = k8sManager.getKubeConfig();
-        // Get the current context name
-        const currentContextName = kc.getCurrentContext();
-        // If detailed is true, get more information about the context
-        if (input.detailed) {
-            const contexts = kc.getContexts();
-            const currentContext = contexts.find(context => context.name === currentContextName);
-            if (!currentContext) {
-                throw new Error(`Current context '${currentContextName}' not found in available contexts`);
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            name: currentContextName,
-                            cluster: currentContext.cluster,
-                            user: currentContext.user,
-                            namespace: currentContext.namespace || "default"
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        // Simple response with just the context name
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ currentContext: currentContextName }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to get current context: ${error.message}`);
-    }
-}

package/dist/tools/get_events.d.ts

@@ -1,28 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const getEventsSchema: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            namespace: {
-                type: string;
-                description: string;
-            };
-            fieldSelector: {
-                type: string;
-                description: string;
-            };
-        };
-        required: never[];
-    };
-};
-export declare function getEvents(k8sManager: KubernetesManager, params: {
-    namespace?: string;
-    fieldSelector?: string;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

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;
-    }[];
-}>;