mcp-server-kubernetes 0.3.2 → 1.0.0

package/dist/tools/describe_deployment.d.ts

@@ -0,0 +1,26 @@
+import { KubernetesManager } from "../types.js";
+export declare const describeDeploymentSchema: {
+    readonly name: "describe_deployment";
+    readonly description: "Get details about a Kubernetes deployment";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly namespace: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["name", "namespace"];
+    };
+};
+export declare function describeDeployment(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/describe_deployment.js

@@ -0,0 +1,40 @@
+export const describeDeploymentSchema = {
+    name: "describe_deployment",
+    description: "Get details about a Kubernetes deployment",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string" },
+        },
+        required: ["name", "namespace"],
+    },
+};
+export async function describeDeployment(k8sManager, input) {
+    const { body } = await k8sManager
+        .getAppsApi()
+        .readNamespacedDeployment(input.name, input.namespace)
+        .catch((error) => {
+        console.error("Deployment description error:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        throw error;
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    name: body.metadata?.name,
+                    namespace: body.metadata?.namespace,
+                    replicas: body.spec?.replicas,
+                    availableReplicas: body.status?.availableReplicas,
+                    spec: body.spec,
+                    status: body.status,
+                }, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/port_forward.d.ts

@@ -0,0 +1,55 @@
+import { KubernetesManager } from "../utils/kubernetes-manager.js";
+export declare const PortForwardSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            resourceType: {
+                type: string;
+            };
+            resourceName: {
+                type: string;
+            };
+            localPort: {
+                type: string;
+            };
+            targetPort: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function startPortForward(k8sManager: KubernetesManager, input: {
+    resourceType: string;
+    resourceName: string;
+    localPort: number;
+    targetPort: number;
+}): Promise<{
+    content: {
+        success: boolean;
+        message: string;
+    }[];
+}>;
+export declare const StopPortForwardSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function stopPortForward(k8sManager: KubernetesManager, input: {
+    id: string;
+}): Promise<{
+    content: {
+        success: boolean;
+        message: string;
+    }[];
+}>;

package/dist/tools/port_forward.js

@@ -0,0 +1,110 @@
+import { spawn } from "child_process";
+// Use spawn instead of exec because port-forward is a long-running process
+async function executeKubectlCommandAsync(command) {
+    return new Promise((resolve, reject) => {
+        const [cmd, ...args] = command.split(" ");
+        const process = spawn(cmd, args);
+        let output = "";
+        let errorOutput = "";
+        process.stdout.on("data", (data) => {
+            output += data.toString();
+            if (output.includes("Forwarding from")) {
+                resolve({
+                    success: true,
+                    message: "port-forwarding was successful",
+                    pid: process.pid,
+                });
+            }
+        });
+        process.stderr.on("data", (data) => {
+            errorOutput += data.toString();
+        });
+        process.on("error", (error) => {
+            reject(new Error(`Failed to execute port-forward: ${error.message}`));
+        });
+        process.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`Port-forward process exited with code ${code}. Error: ${errorOutput}`));
+            }
+        });
+        // Set a timeout to reject if we don't see the success message
+        setTimeout(() => {
+            if (!output.includes("Forwarding from")) {
+                reject(new Error("port-forwarding failed - no success message received"));
+            }
+        }, 5000);
+    });
+}
+export const PortForwardSchema = {
+    name: "port_forward",
+    description: "Forward a local port to a port on a Kubernetes resource",
+    inputSchema: {
+        type: "object",
+        properties: {
+            resourceType: { type: "string" },
+            resourceName: { type: "string" },
+            localPort: { type: "number" },
+            targetPort: { type: "number" },
+        },
+        required: ["resourceType", "resourceName", "localPort", "targetPort"],
+    },
+};
+export async function startPortForward(k8sManager, input) {
+    let command = `kubectl port-forward ${input.resourceType}/${input.resourceName} ${input.localPort}:${input.targetPort}`;
+    try {
+        const result = await executeKubectlCommandAsync(command);
+        // Track the port-forward process
+        k8sManager.trackPortForward({
+            id: `${input.resourceType}-${input.resourceName}-${input.localPort}`,
+            server: {
+                stop: async () => {
+                    try {
+                        process.kill(result.pid);
+                    }
+                    catch (error) {
+                        console.error(`Failed to stop port-forward process ${result.pid}:`, error);
+                    }
+                },
+            },
+            resourceType: input.resourceType,
+            name: input.resourceName,
+            namespace: "default", // TODO: Make namespace configurable
+            ports: [{ local: input.localPort, remote: input.targetPort }],
+        });
+        return {
+            content: [{ success: result.success, message: result.message }],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to execute port-forward: ${error.message}`);
+    }
+}
+export const StopPortForwardSchema = {
+    name: "stop_port_forward",
+    description: "Stop a port-forward process",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: { type: "string" },
+        },
+        required: ["id"],
+    },
+};
+export async function stopPortForward(k8sManager, input) {
+    const portForward = k8sManager.getPortForward(input.id);
+    if (!portForward) {
+        throw new Error(`Port-forward with id ${input.id} not found`);
+    }
+    try {
+        await portForward.server.stop();
+        k8sManager.removePortForward(input.id);
+        return {
+            content: [
+                { success: true, message: "port-forward stopped successfully" },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to stop port-forward: ${error.message}`);
+    }
+}

package/dist/utils/sse.d.ts

@@ -0,0 +1,2 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function startSSEServer(server: Server): void;

package/dist/utils/sse.js

@@ -0,0 +1,27 @@
+import express from "express";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+export function startSSEServer(server) {
+    const app = express();
+    // Currently just copying from docs & allowing for multiple transport connections: https://modelcontextprotocol.io/docs/concepts/transports#server-sent-events-sse
+    // TODO: If exposed to web, then this will enable any client to connect to the server via http - so marked as UNSAFE until mcp has a proper auth solution.
+    let transports = [];
+    app.get("/sse", async (req, res) => {
+        const transport = new SSEServerTransport("/messages", res);
+        transports.push(transport);
+        await server.connect(transport);
+    });
+    app.post("/messages", (req, res) => {
+        const transport = transports.find((t) => t.sessionId === req.query.sessionId);
+        if (transport) {
+            transport.handlePostMessage(req, res);
+        }
+        else {
+            res
+                .status(404)
+                .send("Not found. Must pass valid sessionId as query param.");
+        }
+    });
+    const port = process.env.PORT || 3000;
+    app.listen(port);
+    console.log(`mcp-kubernetes-server is listening on port ${port}\nUse the following url to connect to the server:\n\http://localhost:${port}/sse`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "0.3.2",
+  "version": "1.0.0",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -35,17 +35,19 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@kubernetes/client-node": "^0.20.0",
-    "@modelcontextprotocol/sdk": "1.0.1",
-    "js-yaml": "^4.1.0",
-    "yaml": "^2.7.0",
-    "zod": "^3.24.2"
+    "@kubernetes/client-node": "0.20.0",
+    "@modelcontextprotocol/sdk": "1.7.0",
+    "js-yaml": "4.1.0",
+    "yaml": "2.7.0",
+    "zod": "3.23.8",
+    "express": "4.21.2"
   },
   "devDependencies": {
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^22.9.3",
-    "shx": "^0.3.4",
-    "typescript": "^5.6.2",
+    "@types/express": "5.0.1",
+    "@types/js-yaml": "4.0.9",
+    "@types/node": "22.9.3",
+    "shx": "0.3.4",
+    "typescript": "5.6.2",
     "vitest": "2.1.9"
   }
 }