mcp-server-kubernetes 1.6.2 → 2.0.0

package/dist/tools/list_nodes.js

@@ -1,21 +0,0 @@
-export const listNodesSchema = {
-    name: "list_nodes",
-    description: "List all nodes in the cluster",
-    inputSchema: {
-        type: "object",
-        properties: {},
-    },
-};
-export async function listNodes(k8sManager) {
-    const { body } = await k8sManager.getCoreApi().listNode();
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    nodes: body.items,
-                }, null, 2),
-            },
-        ],
-    };
-}

package/dist/tools/list_pods.d.ts

@@ -1,23 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const listPodsSchema: {
-    readonly name: "list_pods";
-    readonly description: "List pods 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 listPods(k8sManager: KubernetesManager, input: {
-    namespace?: string;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/list_pods.js

@@ -1,29 +0,0 @@
-export const listPodsSchema = {
-    name: "list_pods",
-    description: "List pods in a namespace",
-    inputSchema: {
-        type: "object",
-        properties: {
-            namespace: { type: "string", default: "default" },
-        },
-        required: ["namespace"],
-    },
-};
-export async function listPods(k8sManager, input) {
-    const namespace = input.namespace || "default";
-    const { body } = await k8sManager.getCoreApi().listNamespacedPod(namespace);
-    const pods = body.items.map((pod) => ({
-        name: pod.metadata?.name || "",
-        namespace: pod.metadata?.namespace || "",
-        phase: pod.status?.phase,
-        createdAt: pod.metadata?.creationTimestamp,
-    }));
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({ pods }, null, 2),
-            },
-        ],
-    };
-}

package/dist/tools/list_services.d.ts

@@ -1,23 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const listServicesSchema: {
-    readonly name: "list_services";
-    readonly description: "List services 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 listServices(k8sManager: KubernetesManager, input: {
-    namespace?: string;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/list_services.js

@@ -1,31 +0,0 @@
-export const listServicesSchema = {
-    name: "list_services",
-    description: "List services in a namespace",
-    inputSchema: {
-        type: "object",
-        properties: {
-            namespace: { type: "string", default: "default" },
-        },
-        required: ["namespace"],
-    },
-};
-export async function listServices(k8sManager, input) {
-    const namespace = input.namespace || "default";
-    const { body } = await k8sManager.getCoreApi().listNamespacedService(namespace);
-    const services = body.items.map((service) => ({
-        name: service.metadata?.name || "",
-        namespace: service.metadata?.namespace || "",
-        type: service.spec?.type,
-        clusterIP: service.spec?.clusterIP,
-        ports: service.spec?.ports || [],
-        createdAt: service.metadata?.creationTimestamp,
-    }));
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({ services }, null, 2),
-            },
-        ],
-    };
-}

package/dist/tools/scale_deployment.js

@@ -1,50 +0,0 @@
-export const scaleDeploymentSchema = {
-    name: "scale_deployment",
-    description: "Scale a Kubernetes deployment",
-    inputSchema: {
-        type: "object",
-        properties: {
-            name: { type: "string" },
-            namespace: { type: "string" },
-            replicas: { type: "number" }
-        },
-        required: ["name", "namespace", "replicas"]
-    }
-};
-export async function scaleDeployment(k8sManager, input) {
-    try {
-        const scale = k8sManager.getAppsApi().readNamespacedDeploymentScale(input.name, input.namespace);
-        (await scale).body.spec.replicas = input.replicas;
-        const result = await k8sManager.getAppsApi().replaceNamespacedDeploymentScale(input.name, input.namespace, (await scale).body);
-        if (result.response?.statusCode !== undefined && result.response.statusCode >= 200 && result.response.statusCode < 300) {
-            return {
-                content: [
-                    {
-                        success: true,
-                        message: `Scaled deployment ${input.name} to ${input.replicas} replicas`
-                    }
-                ]
-            };
-        }
-        else {
-            return {
-                content: [
-                    {
-                        success: false,
-                        message: `Failed to scale deployment ${input.name} to ${input.replicas} replicas`
-                    }
-                ]
-            };
-        }
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    success: false,
-                    message: `Failed to scale deployment ${error.message}`
-                }
-            ]
-        };
-    }
-}

package/dist/tools/set_current_context.d.ts

@@ -1,23 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const setCurrentContextSchema: {
-    readonly name: "set_current_context";
-    readonly description: "Set the current Kubernetes context";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly name: {
-                readonly type: "string";
-                readonly description: "Name of the context to set as current";
-            };
-        };
-        readonly required: readonly ["name"];
-    };
-};
-export declare function setCurrentContext(k8sManager: KubernetesManager, input: {
-    name: string;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/set_current_context.js

@@ -1,35 +0,0 @@
-export const setCurrentContextSchema = {
-    name: "set_current_context",
-    description: "Set the current Kubernetes context",
-    inputSchema: {
-        type: "object",
-        properties: {
-            name: {
-                type: "string",
-                description: "Name of the context to set as current"
-            }
-        },
-        required: ["name"],
-    },
-};
-export async function setCurrentContext(k8sManager, input) {
-    try {
-        // Set the current context
-        k8sManager.setCurrentContext(input.name);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        success: true,
-                        message: `Current context set to '${input.name}'`,
-                        context: input.name
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to set current context: ${error.message}`);
-    }
-}

package/dist/tools/update_configmap.d.ts

@@ -1,33 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const UpdateConfigMapSchema: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            name: {
-                type: string;
-            };
-            namespace: {
-                type: string;
-            };
-            data: {
-                type: string;
-                ConfigData: {
-                    type: string;
-                };
-            };
-        };
-        required: string[];
-    };
-};
-export declare function updateConfigMap(k8sManager: KubernetesManager, input: {
-    name: string;
-    namespace: string;
-    data: Record<string, string>;
-}): Promise<{
-    content: {
-        success: boolean;
-        message: string;
-    }[];
-}>;

package/dist/tools/update_configmap.js

@@ -1,71 +0,0 @@
-export const UpdateConfigMapSchema = {
-    name: "update_configmap",
-    description: "Update an existing Kubernetes ConfigMap",
-    inputSchema: {
-        type: "object",
-        properties: {
-            name: { type: "string" },
-            namespace: { type: "string" },
-            data: {
-                type: "object",
-                ConfigData: { type: "string" },
-            },
-        },
-        required: ["name", "namespace", "data"],
-    },
-};
-export async function updateConfigMap(k8sManager, input) {
-    try {
-        // Fetch the existing ConfigMap
-        const existing = await k8sManager.getCoreApi().readNamespacedConfigMap(input.name, input.namespace);
-        if (!existing.body || !existing.body.metadata) {
-            return {
-                content: [
-                    {
-                        success: false,
-                        message: `ConfigMap ${input.name} in namespace ${input.namespace} not found.`,
-                    },
-                ],
-            };
-        }
-        // Update the data
-        const updatedConfigMap = {
-            ...existing.body,
-            data: input.data,
-        };
-        const response = await k8sManager.getCoreApi().replaceNamespacedConfigMap(input.name, input.namespace, updatedConfigMap);
-        if (response.response?.statusCode !== undefined &&
-            (response.response.statusCode === 200 ||
-                response.response.statusCode === 201 ||
-                response.response.statusCode === 202)) {
-            return {
-                content: [
-                    {
-                        success: true,
-                        message: `Updated ConfigMap ${input.name} in namespace ${input.namespace}`,
-                    },
-                ],
-            };
-        }
-        else {
-            return {
-                content: [
-                    {
-                        success: false,
-                        message: `Failed to update ConfigMap ${input.name} in namespace ${input.namespace}`,
-                    },
-                ],
-            };
-        }
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    success: false,
-                    message: `Failed to update ConfigMap ${input.name} in namespace ${input.namespace}. Error: ${error.message}`,
-                },
-            ],
-        };
-    }
-}

package/dist/tools/update_deployment.d.ts

@@ -1,113 +0,0 @@
-import { KubernetesManager } from "../types.js";
-import { CustomContainerConfigType } from "../config/container-templates.js";
-export declare const updateDeploymentSchema: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        required: string[];
-        properties: {
-            name: {
-                type: string;
-            };
-            namespace: {
-                type: string;
-            };
-            template: {
-                type: string;
-                enum: ["ubuntu", "nginx", "busybox", "alpine", "custom"];
-            };
-            containerName: {
-                type: string;
-                description: string;
-            };
-            replicas: {
-                type: string;
-            };
-            customConfig: {
-                type: string;
-                properties: {
-                    image: {
-                        type: string;
-                    };
-                    command: {
-                        type: string;
-                        items: {
-                            type: string;
-                        };
-                    };
-                    args: {
-                        type: string;
-                        items: {
-                            type: string;
-                        };
-                    };
-                    ports: {
-                        type: string;
-                        items: {
-                            type: string;
-                            properties: {
-                                containerPort: {
-                                    type: string;
-                                };
-                                name: {
-                                    type: string;
-                                };
-                                protocol: {
-                                    type: string;
-                                };
-                            };
-                        };
-                    };
-                    resources: {
-                        type: string;
-                        properties: {
-                            limits: {
-                                type: string;
-                                additionalProperties: {
-                                    type: string;
-                                };
-                            };
-                            requests: {
-                                type: string;
-                                additionalProperties: {
-                                    type: string;
-                                };
-                            };
-                        };
-                    };
-                    env: {
-                        type: string;
-                        items: {
-                            type: string;
-                            properties: {
-                                name: {
-                                    type: string;
-                                };
-                                value: {
-                                    type: string;
-                                };
-                                valueFrom: {
-                                    type: string;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    };
-};
-export declare function updateDeployment(k8sManager: KubernetesManager, params: {
-    name: string;
-    namespace: string;
-    template: string;
-    containerName?: string;
-    replicas?: number;
-    customConfig?: CustomContainerConfigType;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/tools/update_deployment.js

@@ -1,155 +0,0 @@
-import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
-import { ContainerTemplate, containerTemplates, CustomContainerConfig, } from "../config/container-templates.js";
-export const updateDeploymentSchema = {
-    name: "update_deployment",
-    description: "Update an existing kubernetes deployment in cluster",
-    inputSchema: {
-        type: "object",
-        required: ["name", "namespace", "template"],
-        properties: {
-            name: { type: "string" },
-            namespace: { type: "string" },
-            template: {
-                type: "string",
-                enum: ContainerTemplate.options,
-            },
-            containerName: {
-                type: "string",
-                description: "Name of the container to update",
-            },
-            replicas: { type: "number" },
-            customConfig: {
-                type: "object",
-                properties: {
-                    image: { type: "string" },
-                    command: { type: "array", items: { type: "string" } },
-                    args: { type: "array", items: { type: "string" } },
-                    ports: {
-                        type: "array",
-                        items: {
-                            type: "object",
-                            properties: {
-                                containerPort: { type: "number" },
-                                name: { type: "string" },
-                                protocol: { type: "string" },
-                            },
-                        },
-                    },
-                    resources: {
-                        type: "object",
-                        properties: {
-                            limits: {
-                                type: "object",
-                                additionalProperties: { type: "string" },
-                            },
-                            requests: {
-                                type: "object",
-                                additionalProperties: { type: "string" },
-                            },
-                        },
-                    },
-                    env: {
-                        type: "array",
-                        items: {
-                            type: "object",
-                            properties: {
-                                name: { type: "string" },
-                                value: { type: "string" },
-                                valueFrom: { type: "object" },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    },
-};
-export async function updateDeployment(k8sManager, params) {
-    // Get existing deployment
-    const { body: existingDeployment } = await k8sManager
-        .getAppsApi()
-        .readNamespacedDeployment(params.name, params.namespace)
-        .catch((error) => {
-        console.error("Deployment read error:", {
-            status: error.response?.statusCode,
-            message: error.response?.body?.message || error.message,
-            details: error.response?.body,
-        });
-        throw error;
-    });
-    // Find target container
-    const containers = existingDeployment.spec.template.spec.containers;
-    let targetContainerIndex = params.containerName
-        ? containers.findIndex(c => c.name === params.containerName)
-        : 0;
-    if (targetContainerIndex === -1) {
-        throw new McpError(ErrorCode.InvalidRequest, `Container '${params.containerName}' not found in deployment`);
-    }
-    // Prepare container config
-    const templateConfig = containerTemplates[params.template];
-    let containerConfig;
-    if (params.template === "custom") {
-        if (!params.customConfig) {
-            throw new McpError(ErrorCode.InvalidRequest, "Custom container configuration is required when using 'custom' template");
-        }
-        const validatedConfig = CustomContainerConfig.parse(params.customConfig);
-        containerConfig = {
-            ...containers[targetContainerIndex],
-            ...templateConfig,
-            image: validatedConfig.image,
-            command: validatedConfig.command,
-            args: validatedConfig.args,
-            ports: validatedConfig.ports,
-            resources: validatedConfig.resources,
-            env: validatedConfig.env,
-        };
-    }
-    else {
-        containerConfig = {
-            ...containers[targetContainerIndex],
-            ...templateConfig,
-        };
-    }
-    // Update deployment
-    const updatedContainers = [...containers];
-    updatedContainers[targetContainerIndex] = containerConfig;
-    const updatedDeployment = {
-        ...existingDeployment,
-        spec: {
-            ...existingDeployment.spec,
-            replicas: params.replicas ?? existingDeployment.spec.replicas,
-            template: {
-                ...existingDeployment.spec.template,
-                spec: {
-                    ...existingDeployment.spec.template.spec,
-                    containers: updatedContainers,
-                },
-            },
-        },
-    };
-    const { body } = await k8sManager
-        .getAppsApi()
-        .replaceNamespacedDeployment(params.name, params.namespace, updatedDeployment)
-        .catch((error) => {
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(ErrorCode.InternalError, `Failed to update deployment: ${error}`);
-    });
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    message: "Deployment updated successfully",
-                    deployment: {
-                        name: body.metadata?.name,
-                        namespace: body.metadata?.namespace,
-                        replicas: body.spec?.replicas,
-                        image: body.spec?.template.spec?.containers[targetContainerIndex].image,
-                        containerName: body.spec?.template.spec?.containers[targetContainerIndex].name,
-                    },
-                }, null, 2),
-            },
-        ],
-    };
-}

package/dist/tools/update_service.d.ts

@@ -1,72 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const updateServiceSchema: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        required: string[];
-        properties: {
-            name: {
-                type: string;
-            };
-            namespace: {
-                type: string;
-                default: string;
-            };
-            type: {
-                type: string;
-                enum: string[];
-            };
-            selector: {
-                type: string;
-                additionalProperties: {
-                    type: string;
-                };
-            };
-            ports: {
-                type: string;
-                items: {
-                    type: string;
-                    properties: {
-                        port: {
-                            type: string;
-                        };
-                        targetPort: {
-                            type: string;
-                        };
-                        protocol: {
-                            type: string;
-                            enum: string[];
-                            default: string;
-                        };
-                        name: {
-                            type: string;
-                        };
-                        nodePort: {
-                            type: string;
-                        };
-                    };
-                    required: string[];
-                };
-            };
-        };
-    };
-};
-export declare function updateService(k8sManager: KubernetesManager, params: {
-    name: string;
-    namespace: string;
-    type?: "ClusterIP" | "NodePort" | "LoadBalancer";
-    selector?: Record<string, string>;
-    ports?: Array<{
-        port: number;
-        targetPort?: number;
-        protocol?: string;
-        name?: string;
-        nodePort?: number;
-    }>;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;