mcp-server-kubernetes 0.1.5 → 0.2.3

package/dist/tools/helm-operations.js

@@ -0,0 +1,198 @@
+import { execSync } from "child_process";
+import { writeFileSync, unlinkSync } from "fs";
+import yaml from "yaml";
+export const installHelmChartSchema = {
+    name: "install_helm_chart",
+    description: "Install a Helm chart",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Release name",
+            },
+            chart: {
+                type: "string",
+                description: "Chart name",
+            },
+            repo: {
+                type: "string",
+                description: "Chart repository URL",
+            },
+            namespace: {
+                type: "string",
+                description: "Kubernetes namespace",
+            },
+            values: {
+                type: "object",
+                description: "Chart values",
+                additionalProperties: true,
+            },
+        },
+        required: ["name", "chart", "repo", "namespace"],
+    },
+};
+export const upgradeHelmChartSchema = {
+    name: "upgrade_helm_chart",
+    description: "Upgrade a Helm release",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Release name",
+            },
+            chart: {
+                type: "string",
+                description: "Chart name",
+            },
+            repo: {
+                type: "string",
+                description: "Chart repository URL",
+            },
+            namespace: {
+                type: "string",
+                description: "Kubernetes namespace",
+            },
+            values: {
+                type: "object",
+                description: "Chart values",
+                additionalProperties: true,
+            },
+        },
+        required: ["name", "chart", "repo", "namespace"],
+    },
+};
+export const uninstallHelmChartSchema = {
+    name: "uninstall_helm_chart",
+    description: "Uninstall a Helm release",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Release name",
+            },
+            namespace: {
+                type: "string",
+                description: "Kubernetes namespace",
+            },
+        },
+        required: ["name", "namespace"],
+    },
+};
+const executeHelmCommand = (command) => {
+    try {
+        return execSync(command, { encoding: "utf8" });
+    }
+    catch (error) {
+        throw new Error(`Helm command failed: ${error.message}`);
+    }
+};
+const writeValuesFile = (name, values) => {
+    const filename = `${name}-values.yaml`;
+    writeFileSync(filename, yaml.stringify(values));
+    return filename;
+};
+export async function installHelmChart(params) {
+    try {
+        // Add helm repository if provided
+        if (params.repo) {
+            const repoName = params.chart.split("/")[0];
+            executeHelmCommand(`helm repo add ${repoName} ${params.repo}`);
+            executeHelmCommand("helm repo update");
+        }
+        let command = `helm install ${params.name} ${params.chart} --namespace ${params.namespace} --create-namespace`;
+        // Handle values if provided
+        if (params.values) {
+            const valuesFile = writeValuesFile(params.name, params.values);
+            command += ` -f ${valuesFile}`;
+            try {
+                executeHelmCommand(command);
+            }
+            finally {
+                // Cleanup values file
+                unlinkSync(valuesFile);
+            }
+        }
+        else {
+            executeHelmCommand(command);
+        }
+        const response = {
+            status: "installed",
+            message: `Successfully installed ${params.name}`,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to install Helm chart: ${error.message}`);
+    }
+}
+export async function upgradeHelmChart(params) {
+    try {
+        // Add helm repository if provided
+        if (params.repo) {
+            const repoName = params.chart.split("/")[0];
+            executeHelmCommand(`helm repo add ${repoName} ${params.repo}`);
+            executeHelmCommand("helm repo update");
+        }
+        let command = `helm upgrade ${params.name} ${params.chart} --namespace ${params.namespace}`;
+        // Handle values if provided
+        if (params.values) {
+            const valuesFile = writeValuesFile(params.name, params.values);
+            command += ` -f ${valuesFile}`;
+            try {
+                executeHelmCommand(command);
+            }
+            finally {
+                // Cleanup values file
+                unlinkSync(valuesFile);
+            }
+        }
+        else {
+            executeHelmCommand(command);
+        }
+        const response = {
+            status: "upgraded",
+            message: `Successfully upgraded ${params.name}`,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to upgrade Helm chart: ${error.message}`);
+    }
+}
+export async function uninstallHelmChart(params) {
+    try {
+        executeHelmCommand(`helm uninstall ${params.name} --namespace ${params.namespace}`);
+        const response = {
+            status: "uninstalled",
+            message: `Successfully uninstalled ${params.name}`,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to uninstall Helm chart: ${error.message}`);
+    }
+}

package/dist/tools/list_deployments.d.ts

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,30 @@
+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_nodes.d.ts

@@ -0,0 +1,15 @@
+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;
+    }[];
+}>;

package/dist/tools/list_nodes.js

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,29 @@
+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 || "",
+        status: pod.status?.phase,
+        createdAt: pod.metadata?.creationTimestamp,
+    }));
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ pods }, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/list_services.d.ts

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,31 @@
+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),
+            },
+        ],
+    };
+}