mcp-server-kubernetes 1.6.2 → 2.1.0

package/dist/index.js

@@ -1,111 +1,75 @@
 #!/usr/bin/env node
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { listPods, listPodsSchema } from "./tools/list_pods.js";
-import { listNodes, listNodesSchema } from "./tools/list_nodes.js";
-import { listServices, listServicesSchema } from "./tools/list_services.js";
-import { listDeployments, listDeploymentsSchema, } from "./tools/list_deployments.js";
-import { listCronJobs, listCronJobsSchema } from "./tools/list_cronjobs.js";
-import { describeCronJob, describeCronJobSchema, } from "./tools/describe_cronjob.js";
-import { listJobs, listJobsSchema } from "./tools/list_jobs.js";
-import { getJobLogs, getJobLogsSchema } from "./tools/get_job_logs.js";
-import { describeNode, describeNodeSchema } from "./tools/describe_node.js";
 import { installHelmChart, installHelmChartSchema, upgradeHelmChart, upgradeHelmChartSchema, uninstallHelmChart, uninstallHelmChartSchema, } from "./tools/helm-operations.js";
 import { explainResource, explainResourceSchema, listApiResources, listApiResourcesSchema, } from "./tools/kubectl-operations.js";
-import { createNamespace, createNamespaceSchema, } from "./tools/create_namespace.js";
-import { createPod, createPodSchema } from "./tools/create_pod.js";
-import { createCronJob, createCronJobSchema } from "./tools/create_cronjob.js";
-import { DeleteCronJob, DeleteCronJobSchema } from "./tools/delete_cronjob.js";
-import { deletePod, deletePodSchema } from "./tools/delete_pod.js";
-import { describePod, describePodSchema } from "./tools/describe_pod.js";
-import { getLogs, getLogsSchema } from "./tools/get_logs.js";
-import { getEvents, getEventsSchema } from "./tools/get_events.js";
 import { getResourceHandlers } from "./resources/handlers.js";
 import { ListResourcesRequestSchema, ReadResourceRequestSchema, ListToolsRequestSchema, CallToolRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import { KubernetesManager } from "./types.js";
 import { serverConfig } from "./config/server-config.js";
-import { createDeploymentSchema } from "./config/deployment-config.js";
-import { listNamespacesSchema } from "./config/namespace-config.js";
-import { deleteNamespace, deleteNamespaceSchema, } from "./tools/delete_namespace.js";
 import { cleanupSchema } from "./config/cleanup-config.js";
 import { startSSEServer } from "./utils/sse.js";
 import { startPortForward, PortForwardSchema, stopPortForward, StopPortForwardSchema, } from "./tools/port_forward.js";
-import { deleteDeployment, deleteDeploymentSchema, } from "./tools/delete_deployment.js";
-import { createDeployment } from "./tools/create_deployment.js";
-import { scaleDeployment, scaleDeploymentSchema, } from "./tools/scale_deployment.js";
-import { describeDeployment, describeDeploymentSchema, } from "./tools/describe_deployment.js";
-import { updateDeployment, updateDeploymentSchema, } from "./tools/update_deployment.js";
-import { createConfigMap, CreateConfigMapSchema, } from "./tools/create_configmap.js";
-import { getConfigMap } from "./tools/get_configmap.js";
-import { updateConfigMap } from "./tools/update_configmap.js";
-import { deleteConfigMap } from "./tools/delete_configmap.js";
-import { listContexts, listContextsSchema } from "./tools/list_contexts.js";
-import { getCurrentContext, getCurrentContextSchema, } from "./tools/get_current_context.js";
-import { setCurrentContext, setCurrentContextSchema, } from "./tools/set_current_context.js";
-import { createService, createServiceSchema } from "./tools/create_service.js";
-import { describeService, describeServiceSchema, } from "./tools/describe_service.js";
-import { updateService, updateServiceSchema } from "./tools/update_service.js";
-import { deleteService, deleteServiceSchema } from "./tools/delete_service.js";
+import { kubectlScale, kubectlScaleSchema } from "./tools/kubectl-scale.js";
+import { kubectlContext, kubectlContextSchema } from "./tools/kubectl-context.js";
+import { kubectlGet, kubectlGetSchema } from "./tools/kubectl-get.js";
+import { kubectlDescribe, kubectlDescribeSchema } from "./tools/kubectl-describe.js";
+import { kubectlList, kubectlListSchema } from "./tools/kubectl-list.js";
+import { kubectlApply, kubectlApplySchema } from "./tools/kubectl-apply.js";
+import { kubectlDelete, kubectlDeleteSchema } from "./tools/kubectl-delete.js";
+import { kubectlCreate, kubectlCreateSchema } from "./tools/kubectl-create.js";
+import { kubectlLogs, kubectlLogsSchema } from "./tools/kubectl-logs.js";
+import { kubectlGeneric, kubectlGenericSchema } from "./tools/kubectl-generic.js";
+import { kubectlPatch, kubectlPatchSchema } from "./tools/kubectl-patch.js";
+import { kubectlRollout, kubectlRolloutSchema } from "./tools/kubectl-rollout.js";
 // Check if non-destructive tools only mode is enabled
 const nonDestructiveTools = process.env.ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS === "true";
 // Define destructive tools (delete and uninstall operations)
 const destructiveTools = [
-    deletePodSchema,
-    deleteServiceSchema,
-    deleteDeploymentSchema,
-    deleteNamespaceSchema,
+    kubectlDeleteSchema, // This replaces all individual delete operations 
     uninstallHelmChartSchema,
-    DeleteCronJobSchema,
     cleanupSchema, // Cleanup is also destructive as it deletes resources
 ];
 // Get all available tools
 const allTools = [
+    // Core operation tools
     cleanupSchema,
-    createDeploymentSchema,
-    createNamespaceSchema,
-    createPodSchema,
-    createCronJobSchema,
-    createServiceSchema,
-    deletePodSchema,
-    deleteDeploymentSchema,
-    deleteNamespaceSchema,
-    deleteServiceSchema,
-    describeCronJobSchema,
-    describePodSchema,
-    describeNodeSchema,
-    describeDeploymentSchema,
-    describeServiceSchema,
+    // Unified kubectl-style tools - these replace many specific tools
+    kubectlGetSchema,
+    kubectlDescribeSchema,
+    kubectlListSchema,
+    kubectlApplySchema,
+    kubectlDeleteSchema,
+    kubectlCreateSchema,
+    kubectlLogsSchema,
+    kubectlScaleSchema,
+    kubectlPatchSchema,
+    kubectlRolloutSchema,
+    // Kubernetes context management
+    kubectlContextSchema,
+    // Special operations that aren't covered by simple kubectl commands
     explainResourceSchema,
-    getEventsSchema,
-    getJobLogsSchema,
-    getLogsSchema,
+    // Helm operations
     installHelmChartSchema,
-    listApiResourcesSchema,
-    listCronJobsSchema,
-    listContextsSchema,
-    getCurrentContextSchema,
-    setCurrentContextSchema,
-    listDeploymentsSchema,
-    listJobsSchema,
-    listNamespacesSchema,
-    listNodesSchema,
-    listPodsSchema,
-    listServicesSchema,
-    uninstallHelmChartSchema,
-    updateDeploymentSchema,
     upgradeHelmChartSchema,
+    uninstallHelmChartSchema,
+    // Port forwarding
     PortForwardSchema,
     StopPortForwardSchema,
-    scaleDeploymentSchema,
-    DeleteCronJobSchema,
-    CreateConfigMapSchema,
-    updateServiceSchema,
+    // API resource operations
+    listApiResourcesSchema,
+    // Generic kubectl command
+    kubectlGenericSchema,
 ];
 const k8sManager = new KubernetesManager();
 const server = new Server({
     name: serverConfig.name,
     version: serverConfig.version,
 }, serverConfig);
+// Resources handlers
+const resourceHandlers = getResourceHandlers(k8sManager);
+server.setRequestHandler(ListResourcesRequestSchema, resourceHandlers.listResources);
+server.setRequestHandler(ReadResourceRequestSchema, resourceHandlers.readResource);
 // Tools handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     // Filter out destructive tools if ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS is set to 'true'
@@ -117,6 +81,51 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         const { name, arguments: input = {} } = request.params;
+        // Handle new kubectl-style commands
+        if (name === "kubectl_context") {
+            return await kubectlContext(k8sManager, input);
+        }
+        if (name === "kubectl_get") {
+            return await kubectlGet(k8sManager, input);
+        }
+        if (name === "kubectl_describe") {
+            return await kubectlDescribe(k8sManager, input);
+        }
+        if (name === "kubectl_list") {
+            return await kubectlList(k8sManager, input);
+        }
+        if (name === "kubectl_apply") {
+            return await kubectlApply(k8sManager, input);
+        }
+        if (name === "kubectl_delete") {
+            return await kubectlDelete(k8sManager, input);
+        }
+        if (name === "kubectl_create") {
+            return await kubectlCreate(k8sManager, input);
+        }
+        if (name === "kubectl_logs") {
+            return await kubectlLogs(k8sManager, input);
+        }
+        if (name === "kubectl_patch") {
+            return await kubectlPatch(k8sManager, input);
+        }
+        if (name === "kubectl_rollout") {
+            return await kubectlRollout(k8sManager, input);
+        }
+        if (name === "kubectl_generic") {
+            return await kubectlGeneric(k8sManager, input);
+        }
+        if (name === "kubectl_events") {
+            return await kubectlGet(k8sManager, {
+                resourceType: "events",
+                namespace: input.namespace,
+                fieldSelector: input.fieldSelector,
+                labelSelector: input.labelSelector,
+                sortBy: input.sortBy,
+                output: input.output
+            });
+        }
+        // Handle specific non-kubectl operations
         switch (name) {
             case "cleanup": {
                 await k8sManager.cleanup();
@@ -131,144 +140,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
-            case "create_namespace": {
-                return await createNamespace(k8sManager, input);
-            }
-            case "create_pod": {
-                return await createPod(k8sManager, input);
-            }
-            case "create_cronjob": {
-                return await createCronJob(k8sManager, input);
-            }
-            case "delete_cronjob": {
-                return await DeleteCronJob(k8sManager, input);
-            }
-            case "delete_pod": {
-                return await deletePod(k8sManager, input);
-            }
-            case "describe_pod": {
-                return await describePod(k8sManager, input);
-            }
-            case "describe_node": {
-                return await describeNode(k8sManager, input);
-            }
             case "explain_resource": {
                 return await explainResource(input);
             }
-            case "get_events": {
-                return await getEvents(k8sManager, input);
-            }
-            case "get_logs": {
-                return await getLogs(k8sManager, input);
-            }
             case "install_helm_chart": {
                 return await installHelmChart(input);
             }
-            case "list_api_resources": {
-                return await listApiResources(input);
-            }
-            case "list_deployments": {
-                return await listDeployments(k8sManager, input);
-            }
-            case "list_namespaces": {
-                const { body } = await k8sManager.getCoreApi().listNamespace();
-                const namespaces = body.items.map((ns) => ({
-                    name: ns.metadata?.name || "",
-                    status: ns.status?.phase || "",
-                    createdAt: ns.metadata?.creationTimestamp,
-                }));
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({ namespaces }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case "list_nodes": {
-                return await listNodes(k8sManager);
-            }
-            case "list_pods": {
-                return await listPods(k8sManager, input);
-            }
-            case "list_services": {
-                return await listServices(k8sManager, input);
-            }
-            case "list_cronjobs": {
-                return await listCronJobs(k8sManager, input);
-            }
-            case "list_contexts": {
-                return await listContexts(k8sManager, input);
-            }
-            case "get_current_context": {
-                return await getCurrentContext(k8sManager, input);
-            }
-            case "set_current_context": {
-                return await setCurrentContext(k8sManager, input);
-            }
-            case "describe_cronjob": {
-                return await describeCronJob(k8sManager, input);
-            }
-            case "list_jobs": {
-                return await listJobs(k8sManager, input);
-            }
-            case "get_job_logs": {
-                return await getJobLogs(k8sManager, input);
-            }
             case "uninstall_helm_chart": {
                 return await uninstallHelmChart(input);
             }
             case "upgrade_helm_chart": {
                 return await upgradeHelmChart(input);
             }
+            case "list_api_resources": {
+                return await listApiResources(input);
+            }
             case "port_forward": {
                 return await startPortForward(k8sManager, input);
             }
             case "stop_port_forward": {
                 return await stopPortForward(k8sManager, input);
             }
-            case "delete_namespace": {
-                return await deleteNamespace(k8sManager, input);
-            }
-            case "delete_deployment": {
-                return await deleteDeployment(k8sManager, input);
-            }
-            case "create_deployment": {
-                return await createDeployment(k8sManager, input);
-            }
-            case "update_deployment": {
-                return await updateDeployment(k8sManager, input);
-            }
-            case "describe_deployment": {
-                return await describeDeployment(k8sManager, input);
-            }
-            case "scale_deployment": {
-                return await scaleDeployment(k8sManager, input);
-            }
-            case "create_configmap": {
-                return await createConfigMap(k8sManager, input);
-            }
-            case "get_configmap": {
-                return await getConfigMap(k8sManager, input);
-            }
-            case "update_configmap": {
-                return await updateConfigMap(k8sManager, input);
-            }
-            case "delete_configmap": {
-                return await deleteConfigMap(k8sManager, input);
-            }
-            case "create_service": {
-                return await createService(k8sManager, input);
-            }
-            case "update_service": {
-                return await updateService(k8sManager, input);
-            }
-            case "delete_service": {
-                return await deleteService(k8sManager, input);
-            }
-            case "describe_service": {
-                return await describeService(k8sManager, input);
+            case "kubectl_scale": {
+                return await kubectlScale(k8sManager, input);
             }
             default:
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
@@ -280,16 +174,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error}`);
     }
 });
-// Resources handlers
-const resourceHandlers = getResourceHandlers(k8sManager);
-server.setRequestHandler(ListResourcesRequestSchema, resourceHandlers.listResources);
-server.setRequestHandler(ReadResourceRequestSchema, resourceHandlers.readResource);
+// Start the server
 if (process.env.ENABLE_UNSAFE_SSE_TRANSPORT) {
     startSSEServer(server);
+    console.log(`SSE server started`);
 }
 else {
     const transport = new StdioServerTransport();
-    await server.connect(transport);
+    console.log(`Starting Kubernetes MCP server v${serverConfig.version}, handling commands...`);
+    server.connect(transport);
 }
 ["SIGINT", "SIGTERM"].forEach((signal) => {
     process.on(signal, async () => {

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

@@ -4,12 +4,12 @@ export declare const ResourceSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    uri: string;
     name: string;
+    uri: string;
     description: string;
 }, {
-    uri: string;
     name: string;
+    uri: string;
     description: string;
 }>;
 export declare const ListResourcesResponseSchema: z.ZodObject<{
@@ -18,24 +18,24 @@ export declare const ListResourcesResponseSchema: z.ZodObject<{
         name: z.ZodString;
         description: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        uri: string;
         name: string;
+        uri: string;
         description: string;
     }, {
-        uri: string;
         name: string;
+        uri: string;
         description: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     resources: {
-        uri: string;
         name: string;
+        uri: string;
         description: string;
     }[];
 }, {
     resources: {
-        uri: string;
         name: string;
+        uri: string;
         description: string;
     }[];
 }>;

package/dist/tools/kubectl-apply.d.ts

@@ -0,0 +1,46 @@
+import { KubernetesManager } from "../types.js";
+export declare const kubectlApplySchema: {
+    readonly name: "kubectl_apply";
+    readonly description: "Apply a Kubernetes YAML manifest from a string or file";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly manifest: {
+                readonly type: "string";
+                readonly description: "YAML manifest to apply";
+            };
+            readonly filename: {
+                readonly type: "string";
+                readonly description: "Path to a YAML file to apply (optional - use either manifest or filename)";
+            };
+            readonly namespace: {
+                readonly type: "string";
+                readonly description: "Namespace to apply the resource to (optional)";
+                readonly default: "default";
+            };
+            readonly dryRun: {
+                readonly type: "boolean";
+                readonly description: "If true, only validate the resource, don't apply it";
+                readonly default: false;
+            };
+            readonly force: {
+                readonly type: "boolean";
+                readonly description: "If true, immediately remove resources from API and bypass graceful deletion";
+                readonly default: false;
+            };
+        };
+        readonly required: readonly [];
+    };
+};
+export declare function kubectlApply(k8sManager: KubernetesManager, input: {
+    manifest?: string;
+    filename?: string;
+    namespace?: string;
+    dryRun?: boolean;
+    force?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/kubectl-apply.js

@@ -0,0 +1,110 @@
+import { execSync } from "child_process";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+export const kubectlApplySchema = {
+    name: "kubectl_apply",
+    description: "Apply a Kubernetes YAML manifest from a string or file",
+    inputSchema: {
+        type: "object",
+        properties: {
+            manifest: {
+                type: "string",
+                description: "YAML manifest to apply"
+            },
+            filename: {
+                type: "string",
+                description: "Path to a YAML file to apply (optional - use either manifest or filename)"
+            },
+            namespace: {
+                type: "string",
+                description: "Namespace to apply the resource to (optional)",
+                default: "default"
+            },
+            dryRun: {
+                type: "boolean",
+                description: "If true, only validate the resource, don't apply it",
+                default: false
+            },
+            force: {
+                type: "boolean",
+                description: "If true, immediately remove resources from API and bypass graceful deletion",
+                default: false
+            }
+        },
+        required: [],
+    },
+};
+export async function kubectlApply(k8sManager, input) {
+    try {
+        if (!input.manifest && !input.filename) {
+            throw new McpError(ErrorCode.InvalidRequest, "Either manifest or filename must be provided");
+        }
+        const namespace = input.namespace || "default";
+        const dryRun = input.dryRun || false;
+        const force = input.force || false;
+        let command = "kubectl apply";
+        let tempFile = null;
+        // Process manifest content if provided
+        if (input.manifest) {
+            // Create temporary file for the manifest
+            const tmpDir = os.tmpdir();
+            tempFile = path.join(tmpDir, `manifest-${Date.now()}.yaml`);
+            fs.writeFileSync(tempFile, input.manifest);
+            command += ` -f ${tempFile}`;
+        }
+        else if (input.filename) {
+            command += ` -f ${input.filename}`;
+        }
+        // Add namespace
+        command += ` -n ${namespace}`;
+        // Add dry-run flag if requested
+        if (dryRun) {
+            command += " --dry-run=client";
+        }
+        // Add force flag if requested
+        if (force) {
+            command += " --force";
+        }
+        // Execute the command
+        try {
+            const result = execSync(command, { encoding: "utf8" });
+            // Clean up temp file if created
+            if (tempFile) {
+                try {
+                    fs.unlinkSync(tempFile);
+                }
+                catch (err) {
+                    console.warn(`Failed to delete temporary file ${tempFile}: ${err}`);
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            // Clean up temp file if created, even if command failed
+            if (tempFile) {
+                try {
+                    fs.unlinkSync(tempFile);
+                }
+                catch (err) {
+                    console.warn(`Failed to delete temporary file ${tempFile}: ${err}`);
+                }
+            }
+            throw new McpError(ErrorCode.InternalError, `Failed to apply manifest: ${error.message}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to execute kubectl apply command: ${error.message}`);
+    }
+}

package/dist/tools/kubectl-context.d.ts

@@ -0,0 +1,49 @@
+import { KubernetesManager } from "../types.js";
+export declare const kubectlContextSchema: {
+    readonly name: "kubectl_context";
+    readonly description: "Manage Kubernetes contexts - list, get, or set the current context";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly operation: {
+                readonly type: "string";
+                readonly enum: readonly ["list", "get", "set"];
+                readonly description: "Operation to perform: list contexts, get current context, or set current context";
+                readonly default: "list";
+            };
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Name of the context to set as current (required for set operation)";
+            };
+            readonly showCurrent: {
+                readonly type: "boolean";
+                readonly description: "When listing contexts, highlight which one is currently active";
+                readonly default: true;
+            };
+            readonly detailed: {
+                readonly type: "boolean";
+                readonly description: "Include detailed information about the context";
+                readonly default: false;
+            };
+            readonly output: {
+                readonly type: "string";
+                readonly enum: readonly ["json", "yaml", "name", "custom"];
+                readonly description: "Output format";
+                readonly default: "json";
+            };
+        };
+        readonly required: readonly ["operation"];
+    };
+};
+export declare function kubectlContext(k8sManager: KubernetesManager, input: {
+    operation: "list" | "get" | "set";
+    name?: string;
+    showCurrent?: boolean;
+    detailed?: boolean;
+    output?: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;