mcp-server-kubernetes 0.1.5 → 0.2.3

package/dist/models/helm-models.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const HelmResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const HelmValuesSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+export interface HelmOperation {
+    name: string;
+    namespace: string;
+}
+export interface HelmInstallOperation extends HelmOperation {
+    chart: string;
+    repo: string;
+    values?: Record<string, any>;
+}
+export interface HelmUpgradeOperation extends HelmInstallOperation {
+}
+export type HelmResponse = {
+    status: "installed" | "upgraded" | "uninstalled";
+    message?: string;
+};

package/dist/models/helm-models.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const HelmResponseSchema = z.object({
+    content: z.array(z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    })),
+});
+export const HelmValuesSchema = z.record(z.any());

package/dist/models/resource-models.d.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+export declare const ResourceSchema: z.ZodObject<{
+    uri: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uri: string;
+    name: string;
+    description: string;
+}, {
+    uri: string;
+    name: string;
+    description: string;
+}>;
+export declare const ListResourcesResponseSchema: z.ZodObject<{
+    resources: z.ZodArray<z.ZodObject<{
+        uri: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        uri: string;
+        name: string;
+        description: string;
+    }, {
+        uri: string;
+        name: string;
+        description: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    resources: {
+        uri: string;
+        name: string;
+        description: string;
+    }[];
+}, {
+    resources: {
+        uri: string;
+        name: string;
+        description: string;
+    }[];
+}>;
+export declare const ReadResourceResponseSchema: z.ZodObject<{
+    contents: z.ZodArray<z.ZodObject<{
+        uri: z.ZodString;
+        mimeType: z.ZodString;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        uri: string;
+        mimeType: string;
+    }, {
+        text: string;
+        uri: string;
+        mimeType: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    contents: {
+        text: string;
+        uri: string;
+        mimeType: string;
+    }[];
+}, {
+    contents: {
+        text: string;
+        uri: string;
+        mimeType: string;
+    }[];
+}>;
+export type K8sResource = z.infer<typeof ResourceSchema>;
+export interface ResourceTracker {
+    kind: string;
+    name: string;
+    namespace: string;
+    createdAt: Date;
+}
+export interface PortForwardTracker {
+    id: string;
+    server: {
+        stop: () => Promise<void>;
+    };
+    resourceType: string;
+    name: string;
+    namespace: string;
+    ports: {
+        local: number;
+        remote: number;
+    }[];
+}
+export interface WatchTracker {
+    id: string;
+    abort: AbortController;
+    resourceType: string;
+    namespace: string;
+}

package/dist/models/resource-models.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+// Resource schemas
+export const ResourceSchema = z.object({
+    uri: z.string(),
+    name: z.string(),
+    description: z.string(),
+});
+export const ListResourcesResponseSchema = z.object({
+    resources: z.array(ResourceSchema),
+});
+export const ReadResourceResponseSchema = z.object({
+    contents: z.array(z.object({
+        uri: z.string(),
+        mimeType: z.string(),
+        text: z.string(),
+    })),
+});

package/dist/models/response-schemas.d.ts

@@ -0,0 +1,221 @@
+import { z } from "zod";
+export declare const CreatePodResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const CreateDeploymentResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const DeletePodResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const CleanupResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const ListPodsResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const ListDeploymentsResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const ListServicesResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const ListNamespacesResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const ListNodesResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const GetLogsResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/models/response-schemas.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+// Common response structure for tool operations
+const ToolResponseContent = z.object({
+    type: z.literal("text"),
+    text: z.string(),
+});
+export const CreatePodResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const CreateDeploymentResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const DeletePodResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const CleanupResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const ListPodsResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const ListDeploymentsResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const ListServicesResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const ListNamespacesResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const ListNodesResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const GetLogsResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});

package/dist/models/tool-models.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const ToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+}, {
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+}>;
+export declare const ListToolsResponseSchema: z.ZodObject<{
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }, {
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tools: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }[];
+}, {
+    tools: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }[];
+}>;
+export type K8sTool = z.infer<typeof ToolSchema>;

package/dist/models/tool-models.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+// Tool schemas
+export const ToolSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    inputSchema: z.record(z.any()),
+});
+export const ListToolsResponseSchema = z.object({
+    tools: z.array(ToolSchema),
+});

package/dist/resources/handlers.d.ts

@@ -0,0 +1,22 @@
+import { KubernetesManager } from "../types.js";
+export declare const getResourceHandlers: (k8sManager: KubernetesManager) => {
+    listResources: () => Promise<{
+        resources: {
+            uri: string;
+            name: string;
+            mimeType: string;
+            description: string;
+        }[];
+    }>;
+    readResource: (request: {
+        params: {
+            uri: string;
+        };
+    }) => Promise<{
+        contents: {
+            uri: string;
+            mimeType: string;
+            text: string;
+        }[];
+    }>;
+};

package/dist/resources/handlers.js

@@ -0,0 +1,112 @@
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const getResourceHandlers = (k8sManager) => ({
+    listResources: async () => {
+        return {
+            resources: [
+                {
+                    uri: "k8s://default/pods",
+                    name: "Kubernetes Pods",
+                    mimeType: "application/json",
+                    description: "List of pods in the default namespace",
+                },
+                {
+                    uri: "k8s://default/deployments",
+                    name: "Kubernetes Deployments",
+                    mimeType: "application/json",
+                    description: "List of deployments in the default namespace",
+                },
+                {
+                    uri: "k8s://default/services",
+                    name: "Kubernetes Services",
+                    mimeType: "application/json",
+                    description: "List of services in the default namespace",
+                },
+                {
+                    uri: "k8s://namespaces",
+                    name: "Kubernetes Namespaces",
+                    mimeType: "application/json",
+                    description: "List of all namespaces",
+                },
+                {
+                    uri: "k8s://nodes",
+                    name: "Kubernetes Nodes",
+                    mimeType: "application/json",
+                    description: "List of all nodes in the cluster",
+                },
+            ],
+        };
+    },
+    readResource: async (request) => {
+        try {
+            const uri = request.params.uri;
+            const parts = uri.replace("k8s://", "").split("/");
+            const isNamespaces = parts[0] === "namespaces";
+            const isNodes = parts[0] === "nodes";
+            if ((isNamespaces || isNodes) && parts.length === 1) {
+                const fn = isNodes ? "listNode" : "listNamespace";
+                const { body } = await k8sManager.getCoreApi()[fn]();
+                return {
+                    contents: [
+                        {
+                            uri: request.params.uri,
+                            mimeType: "application/json",
+                            text: JSON.stringify(body.items, null, 2),
+                        },
+                    ],
+                };
+            }
+            const [namespace, resourceType] = parts;
+            switch (resourceType) {
+                case "pods": {
+                    const { body } = await k8sManager
+                        .getCoreApi()
+                        .listNamespacedPod(namespace);
+                    return {
+                        contents: [
+                            {
+                                uri: request.params.uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify(body.items, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case "deployments": {
+                    const { body } = await k8sManager
+                        .getAppsApi()
+                        .listNamespacedDeployment(namespace);
+                    return {
+                        contents: [
+                            {
+                                uri: request.params.uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify(body.items, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case "services": {
+                    const { body } = await k8sManager
+                        .getCoreApi()
+                        .listNamespacedService(namespace);
+                    return {
+                        contents: [
+                            {
+                                uri: request.params.uri,
+                                mimeType: "application/json",
+                                text: JSON.stringify(body.items, null, 2),
+                            },
+                        ],
+                    };
+                }
+                default:
+                    throw new McpError(ErrorCode.InvalidRequest, `Unsupported resource type: ${resourceType}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof McpError)
+                throw error;
+            throw new McpError(ErrorCode.InternalError, `Failed to read resource: ${error}`);
+        }
+    },
+});

package/dist/tools/create_pod.d.ts

@@ -0,0 +1,39 @@
+import { KubernetesManager } from "../types.js";
+export declare const createPodSchema: {
+    readonly name: "create_pod";
+    readonly description: "Create a new Kubernetes pod";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly namespace: {
+                readonly type: "string";
+            };
+            readonly template: {
+                readonly type: "string";
+                readonly enum: ["ubuntu", "nginx", "busybox", "alpine"];
+            };
+            readonly command: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly optional: true;
+            };
+        };
+        readonly required: readonly ["name", "namespace", "template"];
+    };
+};
+export declare function createPod(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace: string;
+    template: string;
+    command?: string[];
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;