mcp-server-kubernetes 0.3.2 → 0.4.0

package/README.md

@@ -118,76 +118,36 @@ bun run build
 4. Local Testing with [Inspector](https://github.com/modelcontextprotocol/inspector)
 
 ```bash
-npx @modelcontextprotocol/inspector node build/index.js
+npx @modelcontextprotocol/inspector node dist/index.js
 # Follow further instructions on terminal for Inspector link
 ```
 
-5. Local testing with [mcp-chat](https://github.com/Flux159/mcp-chat)
+5. Local testing with Claude Desktop
 
-```bash
-npm run chat
+```json
+{
+  "mcpServers": {
+    "mcp-server-kubernetes": {
+      "command": "node",
+      "args": ["/path/to/your/mcp-server-kubernetes/dist/index.js"]
+    }
+  }
+}
 ```
 
-### Project Structure
+6. Local testing with [mcp-chat](https://github.com/Flux159/mcp-chat)
 
+```bash
+npm run chat
 ```
-├── src/
-│   ├── index.ts              # Main server implementation
-│   ├── types.ts              # Type re-exports
-│   ├── config/               # Configuration files
-│   │   ├── container-templates.ts  # Container configurations
-│   │   ├── server-config.ts        # Server settings
-│   │   ├── deployment-config.ts    # Deployment schemas
-│   │   ├── namespace-config.ts     # Namespace schemas
-│   │   └── cleanup-config.ts       # Resource cleanup configuration
-│   ├── models/               # Data models and schemas
-│   │   ├── response-schemas.ts     # API response schemas
-│   │   ├── resource-models.ts      # Resource models
-│   │   ├── tool-models.ts          # Tool schemas
-│   │   ├── helm-models.ts          # Helm operation schemas
-│   │   └── kubectl-models.ts       # Kubectl operation schemas
-│   ├── utils/                # Utility classes
-│   │   └── kubernetes-manager.ts   # K8s management
-│   ├── resources/            # Resource handlers
-│   │   └── handlers.ts       # Resource implementation
-│   └── tools/                # Tool implementations
-│       ├── list_pods.ts      # Pod listing operations
-│       ├── list_services.ts  # Service listing operations
-│       ├── list_deployments.ts # Deployment listing operations
-│       ├── list_nodes.ts     # Node listing operations
-│       ├── create_pod.ts     # Pod creation operations
-│       ├── delete_pod.ts     # Pod deletion operations
-│       ├── describe_pod.ts   # Pod description operations
-│       ├── get_logs.ts       # Container logs operations
-│       ├── get_events.ts     # Kubernetes events operations
-│       ├── helm-operations.ts # Helm chart operations
-│       └── kubectl-operations.ts # Kubectl utility operations
-├── tests/                    # Test files
-│   ├── unit.test.ts          # Unit tests for basic operations
-│   ├── helm.test.ts          # Helm-specific tests
-│   └── kubectl.test.ts       # Kubectl-specific tests
-├── .github/                  # GitHub configuration
-│   └── workflows/            # CI/CD workflows
-│       ├── ci.yml            # Continuous integration
-│       └── cd.yml            # Continuous deployment
-├── Dockerfile                # Docker container definition
-├── LICENSE                   # MIT license
-├── README.md                 # Project documentation
-├── package.json              # NPM package configuration
-├── tsconfig.json             # TypeScript configuration
-└── vitest.config.ts          # Test configuration
-```
 
-### Contributing
+## Contributing
+
+See the [CONTRIBUTING.md](CONTRIBUTING.md) file for details.
 
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests for new functionality
-5. Ensure all tests pass
-6. Submit a pull request
+## Advanced
 
-For bigger changes please open an issue first to discuss the proposed changes.
+For more advanced information like using SSE transport, see the [ADVANCED_README.md](ADVANCED_README.md).
 
 ## Architecture
 

package/dist/index.js

@@ -19,6 +19,7 @@ import { serverConfig } from "./config/server-config.js";
 import { createDeploymentSchema } from "./config/deployment-config.js";
 import { listNamespacesSchema } from "./config/namespace-config.js";
 import { cleanupSchema } from "./config/cleanup-config.js";
+import { startSSEServer } from "./utils/sse.js";
 const k8sManager = new KubernetesManager();
 const server = new Server({
     name: serverConfig.name,
@@ -137,8 +138,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 const resourceHandlers = getResourceHandlers(k8sManager);
 server.setRequestHandler(ListResourcesRequestSchema, resourceHandlers.listResources);
 server.setRequestHandler(ReadResourceRequestSchema, resourceHandlers.readResource);
-const transport = new StdioServerTransport();
-await server.connect(transport);
+if (process.env.ENABLE_UNSAFE_SSE_TRANSPORT) {
+    startSSEServer(server);
+}
+else {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
 ["SIGINT", "SIGTERM"].forEach((signal) => {
     process.on(signal, async () => {
         console.log(`Received ${signal}, shutting down...`);

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": "0.4.0",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -39,9 +39,11 @@
     "@modelcontextprotocol/sdk": "1.0.1",
     "js-yaml": "^4.1.0",
     "yaml": "^2.7.0",
-    "zod": "^3.24.2"
+    "zod": "^3.24.2",
+    "express": "4.21.2"
   },
   "devDependencies": {
+    "@types/express": "^5.0.1",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.9.3",
     "shx": "^0.3.4",