mcp-server-kubernetes 1.6.2 → 2.1.0

package/dist/tools/kubectl-patch.js

@@ -0,0 +1,128 @@
+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 kubectlPatchSchema = {
+    name: "kubectl_patch",
+    description: "Update field(s) of a resource using strategic merge patch, JSON merge patch, or JSON patch",
+    inputSchema: {
+        type: "object",
+        properties: {
+            resourceType: {
+                type: "string",
+                description: "Type of resource to patch (e.g., pods, deployments, services)"
+            },
+            name: {
+                type: "string",
+                description: "Name of the resource to patch"
+            },
+            namespace: {
+                type: "string",
+                description: "Namespace of the resource",
+                default: "default"
+            },
+            patchType: {
+                type: "string",
+                description: "Type of patch to apply",
+                enum: ["strategic", "merge", "json"],
+                default: "strategic"
+            },
+            patchData: {
+                type: "object",
+                description: "Patch data as a JSON object"
+            },
+            patchFile: {
+                type: "string",
+                description: "Path to a file containing the patch data (alternative to patchData)"
+            },
+            dryRun: {
+                type: "boolean",
+                description: "If true, only print the object that would be sent, without sending it",
+                default: false
+            }
+        },
+        required: ["resourceType", "name"],
+    }
+};
+export async function kubectlPatch(k8sManager, input) {
+    try {
+        if (!input.patchData && !input.patchFile) {
+            throw new McpError(ErrorCode.InvalidRequest, "Either patchData or patchFile must be provided");
+        }
+        const namespace = input.namespace || "default";
+        const patchType = input.patchType || "strategic";
+        const dryRun = input.dryRun || false;
+        let tempFile = null;
+        // Build the kubectl patch command
+        let command = `kubectl patch ${input.resourceType} ${input.name} -n ${namespace}`;
+        // Add patch type flag
+        switch (patchType) {
+            case "strategic":
+                command += " --type strategic";
+                break;
+            case "merge":
+                command += " --type merge";
+                break;
+            case "json":
+                command += " --type json";
+                break;
+            default:
+                command += " --type strategic";
+        }
+        // Handle patch data
+        if (input.patchData) {
+            // Create a temporary file for the patch data
+            const tmpDir = os.tmpdir();
+            tempFile = path.join(tmpDir, `patch-${Date.now()}.json`);
+            fs.writeFileSync(tempFile, JSON.stringify(input.patchData));
+            command += ` --patch-file ${tempFile}`;
+        }
+        else if (input.patchFile) {
+            command += ` --patch-file ${input.patchFile}`;
+        }
+        // Add dry-run flag if requested
+        if (dryRun) {
+            command += " --dry-run=client";
+        }
+        // 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 patch resource: ${error.message}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to execute kubectl patch command: ${error.message}`);
+    }
+}

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

@@ -0,0 +1,67 @@
+import { KubernetesManager } from "../types.js";
+export declare const kubectlRolloutSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            subCommand: {
+                type: string;
+                description: string;
+                enum: string[];
+                default: string;
+            };
+            resourceType: {
+                type: string;
+                description: string;
+                enum: string[];
+                default: string;
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            namespace: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            revision: {
+                type: string;
+                description: string;
+                optional: boolean;
+            };
+            toRevision: {
+                type: string;
+                description: string;
+                optional: boolean;
+            };
+            timeout: {
+                type: string;
+                description: string;
+                optional: boolean;
+            };
+            watch: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function kubectlRollout(k8sManager: KubernetesManager, input: {
+    subCommand: "history" | "pause" | "restart" | "resume" | "status" | "undo";
+    resourceType: "deployment" | "daemonset" | "statefulset";
+    name: string;
+    namespace?: string;
+    revision?: number;
+    toRevision?: number;
+    timeout?: string;
+    watch?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/kubectl-rollout.js

@@ -0,0 +1,115 @@
+import { execSync } from "child_process";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const kubectlRolloutSchema = {
+    name: "kubectl_rollout",
+    description: "Manage the rollout of a resource (e.g., deployment, daemonset, statefulset)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            subCommand: {
+                type: "string",
+                description: "Rollout subcommand to execute",
+                enum: ["history", "pause", "restart", "resume", "status", "undo"],
+                default: "status"
+            },
+            resourceType: {
+                type: "string",
+                description: "Type of resource to manage rollout for",
+                enum: ["deployment", "daemonset", "statefulset"],
+                default: "deployment"
+            },
+            name: {
+                type: "string",
+                description: "Name of the resource"
+            },
+            namespace: {
+                type: "string",
+                description: "Namespace of the resource",
+                default: "default"
+            },
+            revision: {
+                type: "number",
+                description: "Revision to rollback to (for undo subcommand)",
+                optional: true
+            },
+            toRevision: {
+                type: "number",
+                description: "Revision to roll back to (for history subcommand)",
+                optional: true
+            },
+            timeout: {
+                type: "string",
+                description: "The length of time to wait before giving up (e.g., '30s', '1m', '2m30s')",
+                optional: true
+            },
+            watch: {
+                type: "boolean",
+                description: "Watch the rollout status in real-time until completion",
+                default: false
+            }
+        },
+        required: ["subCommand", "resourceType", "name"]
+    }
+};
+export async function kubectlRollout(k8sManager, input) {
+    try {
+        const namespace = input.namespace || "default";
+        const watch = input.watch || false;
+        // Build the kubectl rollout command
+        let command = `kubectl rollout ${input.subCommand} ${input.resourceType}/${input.name} -n ${namespace}`;
+        // Add revision for undo
+        if (input.subCommand === "undo" && input.revision !== undefined) {
+            command += ` --to-revision=${input.revision}`;
+        }
+        // Add revision for history
+        if (input.subCommand === "history" && input.toRevision !== undefined) {
+            command += ` --revision=${input.toRevision}`;
+        }
+        // Add timeout if specified
+        if (input.timeout) {
+            command += ` --timeout=${input.timeout}`;
+        }
+        // Execute the command
+        try {
+            // For status command with watch flag, we need to handle it differently
+            // since it's meant to be interactive and follow the progress
+            if (input.subCommand === "status" && watch) {
+                command += " --watch";
+                // For watch we are limited in what we can do - we'll execute it with a reasonable timeout
+                // and capture the output until that point
+                const result = execSync(command, {
+                    encoding: "utf8",
+                    timeout: 15000 // Reduced from 30 seconds to 15 seconds
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result + "\n\nNote: Watch operation was limited to 15 seconds. The rollout may still be in progress.",
+                        },
+                    ],
+                };
+            }
+            else {
+                const result = execSync(command, { encoding: "utf8" });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to execute rollout command: ${error.message}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to execute kubectl rollout command: ${error.message}`);
+    }
+}

package/dist/tools/{scale_deployment.d.ts → kubectl-scale.d.ts}

@@ -1,5 +1,5 @@
 import { KubernetesManager } from "../types.js";
-export declare const scaleDeploymentSchema: {
+export declare const kubectlScaleSchema: {
     name: string;
     description: string;
     inputSchema: {
@@ -7,21 +7,31 @@ export declare const scaleDeploymentSchema: {
         properties: {
             name: {
                 type: string;
+                description: string;
             };
             namespace: {
                 type: string;
+                description: string;
+                default: string;
             };
             replicas: {
                 type: string;
+                description: string;
+            };
+            resourceType: {
+                type: string;
+                description: string;
+                default: string;
             };
         };
         required: string[];
     };
 };
-export declare function scaleDeployment(k8sManager: KubernetesManager, input: {
+export declare function kubectlScale(k8sManager: KubernetesManager, input: {
     name: string;
-    namespace: string;
+    namespace?: string;
     replicas: number;
+    resourceType?: string;
 }): Promise<{
     content: {
         success: boolean;

package/dist/tools/kubectl-scale.js

@@ -0,0 +1,73 @@
+import { execSync } from "child_process";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+export const kubectlScaleSchema = {
+    name: "kubectl_scale",
+    description: "Scale a Kubernetes deployment",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Name of the deployment to scale"
+            },
+            namespace: {
+                type: "string",
+                description: "Namespace of the deployment",
+                default: "default"
+            },
+            replicas: {
+                type: "number",
+                description: "Number of replicas to scale to"
+            },
+            resourceType: {
+                type: "string",
+                description: "Resource type to scale (deployment, replicaset, statefulset)",
+                default: "deployment"
+            }
+        },
+        required: ["name", "replicas"]
+    }
+};
+export async function kubectlScale(k8sManager, input) {
+    try {
+        const namespace = input.namespace || "default";
+        const resourceType = input.resourceType || "deployment";
+        // Build the kubectl scale command
+        let command = `kubectl scale ${resourceType} ${input.name} --replicas=${input.replicas} --namespace=${namespace}`;
+        // Execute the command
+        try {
+            const result = execSync(command, { encoding: "utf8" });
+            return {
+                content: [
+                    {
+                        success: true,
+                        message: `Scaled ${resourceType} ${input.name} to ${input.replicas} replicas`
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to scale ${resourceType}: ${error.message}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            return {
+                content: [
+                    {
+                        success: false,
+                        message: error.message
+                    }
+                ]
+            };
+        }
+        return {
+            content: [
+                {
+                    success: false,
+                    message: `Failed to scale resource: ${error.message}`
+                }
+            ]
+        };
+    }
+}

package/dist/utils/kubernetes-manager.d.ts

@@ -9,6 +9,10 @@ export declare class KubernetesManager {
     private k8sAppsApi;
     private k8sBatchApi;
     constructor();
+    /**
+     * A very simple test to check if the application is running inside a Kubernetes cluster
+     */
+    private isRunningInCluster;
     /**
      * Set the current context to the desired context name.
      *

package/dist/utils/kubernetes-manager.js

@@ -1,4 +1,5 @@
 import * as k8s from "@kubernetes/client-node";
+import * as fs from "fs";
 export class KubernetesManager {
     resources = [];
     portForwards = [];
@@ -9,11 +10,28 @@ export class KubernetesManager {
     k8sBatchApi;
     constructor() {
         this.kc = new k8s.KubeConfig();
-        this.kc.loadFromDefault();
+        if (this.isRunningInCluster()) {
+            this.kc.loadFromCluster();
+        }
+        else {
+            this.kc.loadFromDefault();
+        }
         this.k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
         this.k8sAppsApi = this.kc.makeApiClient(k8s.AppsV1Api);
         this.k8sBatchApi = this.kc.makeApiClient(k8s.BatchV1Api);
     }
+    /**
+     * A very simple test to check if the application is running inside a Kubernetes cluster
+     */
+    isRunningInCluster() {
+        const serviceAccountPath = "/var/run/secrets/kubernetes.io/serviceaccount/token";
+        try {
+            return fs.existsSync(serviceAccountPath);
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Set the current context to the desired context name.
      *
@@ -22,10 +40,10 @@ export class KubernetesManager {
     setCurrentContext(contextName) {
         // Get all available contexts
         const contexts = this.kc.getContexts();
-        const contextNames = contexts.map(context => context.name);
+        const contextNames = contexts.map((context) => context.name);
         // Check if the requested context exists
         if (!contextNames.includes(contextName)) {
-            throw new Error(`Context '${contextName}' not found. Available contexts: ${contextNames.join(', ')}`);
+            throw new Error(`Context '${contextName}' not found. Available contexts: ${contextNames.join(", ")}`);
         }
         // Set the current context
         this.kc.setCurrentContext(contextName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "1.6.2",
+  "version": "2.1.0",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",

package/dist/tools/create_configmap.d.ts

@@ -1,33 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const CreateConfigMapSchema: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            name: {
-                type: string;
-            };
-            namespace: {
-                type: string;
-            };
-            data: {
-                type: string;
-                ConfigData: {
-                    type: string;
-                };
-            };
-        };
-        required: string[];
-    };
-};
-export declare function createConfigMap(k8sManager: KubernetesManager, input: {
-    name: string;
-    namespace: string;
-    data: Record<string, string>;
-}): Promise<{
-    content: {
-        success: boolean;
-        message: string;
-    }[];
-}>;

package/dist/tools/create_configmap.js

@@ -1,66 +0,0 @@
-export const CreateConfigMapSchema = {
-    name: "create_configmap",
-    description: "Create a new Kubernetes ConfigMap",
-    inputSchema: {
-        type: "object",
-        properties: {
-            name: { type: "string" },
-            namespace: { type: "string" },
-            data: {
-                type: "object",
-                ConfigData: { type: "string" },
-            },
-        },
-        required: ["name", "namespace", "data"],
-    },
-};
-export async function createConfigMap(k8sManager, input) {
-    try {
-        const configmap = {
-            apiVersion: "v1",
-            kind: "ConfigMap",
-            binaryData: undefined,
-            data: input.data,
-            immutable: false,
-            metadata: {
-                name: input.name,
-                namespace: input.namespace,
-                labels: {
-                    "mcp-managed": "true",
-                    app: input.name,
-                },
-            },
-        };
-        const response = await k8sManager.getCoreApi().createNamespacedConfigMap(input.namespace, configmap);
-        if (response.response?.statusCode !== undefined && (response.response.statusCode == 200 || response.response.statusCode == 201 || response.response.statusCode == 202)) {
-            return {
-                content: [
-                    {
-                        success: true,
-                        message: `Created ConfigMap ${response.body.metadata?.name} in namespace ${response.body.metadata?.namespace}`,
-                    }
-                ]
-            };
-        }
-        else {
-            return {
-                content: [
-                    {
-                        success: false,
-                        message: `Failed to create ConfigMap ${response.body.metadata?.name} in namespace ${response.body.metadata?.namespace}`,
-                    }
-                ]
-            };
-        }
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    success: false,
-                    message: `Failed to create ConfigMap ${input.name} in namespace ${input.namespace}. Error: ${error.message}`,
-                }
-            ]
-        };
-    }
-}

package/dist/tools/create_cronjob.d.ts

@@ -1,47 +0,0 @@
-import { KubernetesManager } from "../types.js";
-export declare const createCronJobSchema: {
-    readonly name: "create_cronjob";
-    readonly description: "Create a new Kubernetes CronJob";
-    readonly inputSchema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly name: {
-                readonly type: "string";
-            };
-            readonly namespace: {
-                readonly type: "string";
-            };
-            readonly schedule: {
-                readonly type: "string";
-            };
-            readonly image: {
-                readonly type: "string";
-            };
-            readonly command: {
-                readonly type: "array";
-                readonly items: {
-                    readonly type: "string";
-                };
-                readonly optional: true;
-            };
-            readonly suspend: {
-                readonly type: "boolean";
-                readonly optional: true;
-            };
-        };
-        readonly required: readonly ["name", "namespace", "schedule", "image"];
-    };
-};
-export declare function createCronJob(k8sManager: KubernetesManager, input: {
-    name: string;
-    namespace: string;
-    schedule: string;
-    image: string;
-    command?: string[];
-    suspend?: boolean;
-}): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;