kubectl-mcp-server 1.13.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

kubectl_mcp_tool/tools/operations.py

@@ -10,6 +10,13 @@ from mcp.types import ToolAnnotations
 logger = logging.getLogger("mcp-server")
 
 
+def _get_kubectl_context_args(context: str) -> List[str]:
+    """Get kubectl context arguments if context is specified."""
+    if context:
+        return ["--context", context]
+    return []
+
+
 def register_operations_tools(server, non_destructive: bool):
     """Register kubectl operations tools (apply, describe, patch, etc.)."""
 
@@ -25,8 +32,14 @@ def register_operations_tools(server, non_destructive: bool):
             destructiveHint=True,
         ),
     )
-    def kubectl_apply(manifest: str, namespace: Optional[str] = "default") -> Dict[str, Any]:
-        """Apply a YAML manifest to the cluster."""
+    def kubectl_apply(manifest: str, namespace: Optional[str] = "default", context: str = "") -> Dict[str, Any]:
+        """Apply a YAML manifest to the cluster.
+
+        Args:
+            manifest: YAML manifest content to apply
+            namespace: Target namespace
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         blocked = check_destructive()
         if blocked:
             return blocked
@@ -35,13 +48,13 @@ def register_operations_tools(server, non_destructive: bool):
                 f.write(manifest)
                 temp_path = f.name
 
-            cmd = ["kubectl", "apply", "-f", temp_path, "-n", namespace]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["apply", "-f", temp_path, "-n", namespace]
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
 
             os.unlink(temp_path)
 
             if result.returncode == 0:
-                return {"success": True, "output": result.stdout.strip()}
+                return {"success": True, "context": context or "current", "output": result.stdout.strip()}
             else:
                 return {"success": False, "error": result.stderr.strip()}
         except Exception as e:
@@ -54,14 +67,21 @@ def register_operations_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def kubectl_describe(resource_type: str, name: str, namespace: Optional[str] = "default") -> Dict[str, Any]:
-        """Describe a Kubernetes resource in detail."""
+    def kubectl_describe(resource_type: str, name: str, namespace: Optional[str] = "default", context: str = "") -> Dict[str, Any]:
+        """Describe a Kubernetes resource in detail.
+
+        Args:
+            resource_type: Type of resource (e.g., pod, deployment, service)
+            name: Name of the resource
+            namespace: Target namespace
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            cmd = ["kubectl", "describe", resource_type, name, "-n", namespace]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["describe", resource_type, name, "-n", namespace]
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
 
             if result.returncode == 0:
-                return {"success": True, "description": result.stdout}
+                return {"success": True, "context": context or "current", "description": result.stdout}
             else:
                 return {"success": False, "error": result.stderr.strip()}
         except Exception as e:
@@ -74,8 +94,13 @@ def register_operations_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def kubectl_generic(command: str) -> Dict[str, Any]:
-        """Execute any kubectl command. Use with caution."""
+    def kubectl_generic(command: str, context: str = "") -> Dict[str, Any]:
+        """Execute any kubectl command. Use with caution.
+
+        Args:
+            command: kubectl command to execute (without kubectl prefix)
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
             # Security: validate command starts with allowed operations
             allowed_prefixes = [
@@ -96,11 +121,12 @@ def register_operations_tools(server, non_destructive: bool):
                     "error": f"Command not allowed. Allowed: {', '.join(allowed_prefixes)}"
                 }
 
-            full_cmd = ["kubectl"] + cmd_parts
+            full_cmd = ["kubectl"] + _get_kubectl_context_args(context) + cmd_parts
             result = subprocess.run(full_cmd, capture_output=True, text=True, timeout=60)
 
             return {
                 "success": result.returncode == 0,
+                "context": context or "current",
                 "output": result.stdout,
                 "error": result.stderr if result.returncode != 0 else None
             }
@@ -114,8 +140,17 @@ def register_operations_tools(server, non_destructive: bool):
             destructiveHint=True,
         ),
     )
-    def kubectl_patch(resource_type: str, name: str, patch: str, patch_type: str = "strategic", namespace: Optional[str] = "default") -> Dict[str, Any]:
-        """Patch a Kubernetes resource."""
+    def kubectl_patch(resource_type: str, name: str, patch: str, patch_type: str = "strategic", namespace: Optional[str] = "default", context: str = "") -> Dict[str, Any]:
+        """Patch a Kubernetes resource.
+
+        Args:
+            resource_type: Type of resource to patch
+            name: Name of the resource
+            patch: JSON patch content
+            patch_type: Type of patch (strategic, merge, json)
+            namespace: Target namespace
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         blocked = check_destructive()
         if blocked:
             return blocked
@@ -126,8 +161,8 @@ def register_operations_tools(server, non_destructive: bool):
                 "json": "json"
             }.get(patch_type, "strategic")
 
-            cmd = [
-                "kubectl", "patch", resource_type, name,
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + [
+                "patch", resource_type, name,
                 "-n", namespace,
                 "--type", type_flag,
                 "-p", patch
@@ -135,7 +170,7 @@ def register_operations_tools(server, non_destructive: bool):
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
 
             if result.returncode == 0:
-                return {"success": True, "output": result.stdout.strip()}
+                return {"success": True, "context": context or "current", "output": result.stdout.strip()}
             else:
                 return {"success": False, "error": result.stderr.strip()}
         except Exception as e:
@@ -148,8 +183,16 @@ def register_operations_tools(server, non_destructive: bool):
             destructiveHint=True,
         ),
     )
-    def kubectl_rollout(action: str, resource_type: str, name: str, namespace: Optional[str] = "default") -> Dict[str, Any]:
-        """Manage rollouts (restart, status, history, undo, pause, resume)."""
+    def kubectl_rollout(action: str, resource_type: str, name: str, namespace: Optional[str] = "default", context: str = "") -> Dict[str, Any]:
+        """Manage rollouts (restart, status, history, undo, pause, resume).
+
+        Args:
+            action: Rollout action (status, history, restart, undo, pause, resume)
+            resource_type: Type of resource (deployment, statefulset, daemonset)
+            name: Name of the resource
+            namespace: Target namespace
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
             allowed_actions = ["status", "history", "restart", "undo", "pause", "resume"]
             if action not in allowed_actions:
@@ -161,11 +204,11 @@ def register_operations_tools(server, non_destructive: bool):
                 if blocked:
                     return blocked
 
-            cmd = ["kubectl", "rollout", action, f"{resource_type}/{name}", "-n", namespace]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["rollout", action, f"{resource_type}/{name}", "-n", namespace]
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
 
             if result.returncode == 0:
-                return {"success": True, "output": result.stdout.strip()}
+                return {"success": True, "context": context or "current", "output": result.stdout.strip()}
             else:
                 return {"success": False, "error": result.stderr.strip()}
         except Exception as e:
@@ -178,18 +221,26 @@ def register_operations_tools(server, non_destructive: bool):
             destructiveHint=True,
         ),
     )
-    def kubectl_create(resource_type: str, name: str, namespace: Optional[str] = "default", image: Optional[str] = None) -> Dict[str, Any]:
-        """Create a Kubernetes resource."""
+    def kubectl_create(resource_type: str, name: str, namespace: Optional[str] = "default", image: Optional[str] = None, context: str = "") -> Dict[str, Any]:
+        """Create a Kubernetes resource.
+
+        Args:
+            resource_type: Type of resource to create
+            name: Name of the resource
+            namespace: Target namespace
+            image: Container image (for deployment/pod)
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         blocked = check_destructive()
         if blocked:
             return blocked
         try:
-            cmd = ["kubectl", "create", resource_type, name, "-n", namespace]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["create", resource_type, name, "-n", namespace]
             if image and resource_type in ["deployment", "pod"]:
                 cmd.extend(["--image", image])
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
             if result.returncode == 0:
-                return {"success": True, "output": result.stdout.strip()}
+                return {"success": True, "context": context or "current", "output": result.stdout.strip()}
             else:
                 return {"success": False, "error": result.stderr.strip()}
         except Exception as e:
@@ -202,16 +253,23 @@ def register_operations_tools(server, non_destructive: bool):
             destructiveHint=True,
         ),
     )
-    def delete_resource(resource_type: str, name: str, namespace: Optional[str] = "default") -> Dict[str, Any]:
-        """Delete a Kubernetes resource."""
+    def delete_resource(resource_type: str, name: str, namespace: Optional[str] = "default", context: str = "") -> Dict[str, Any]:
+        """Delete a Kubernetes resource.
+
+        Args:
+            resource_type: Type of resource to delete
+            name: Name of the resource
+            namespace: Target namespace
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         blocked = check_destructive()
         if blocked:
             return blocked
         try:
-            cmd = ["kubectl", "delete", resource_type, name, "-n", namespace]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["delete", resource_type, name, "-n", namespace]
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
             if result.returncode == 0:
-                return {"success": True, "message": f"Deleted {resource_type}/{name}"}
+                return {"success": True, "context": context or "current", "message": f"Deleted {resource_type}/{name}"}
             else:
                 return {"success": False, "error": result.stderr.strip()}
         except Exception as e:
@@ -224,23 +282,30 @@ def register_operations_tools(server, non_destructive: bool):
             destructiveHint=True,
         ),
     )
-    def kubectl_cp(source: str, destination: str, namespace: str = "default", container: Optional[str] = None) -> Dict[str, Any]:
+    def kubectl_cp(source: str, destination: str, namespace: str = "default", container: Optional[str] = None, context: str = "") -> Dict[str, Any]:
         """Copy files between local filesystem and pods.
 
         Use pod:path format for pod paths, e.g.:
         - Local to pod: kubectl_cp("/tmp/file.txt", "mypod:/tmp/file.txt")
         - Pod to local: kubectl_cp("mypod:/tmp/file.txt", "/tmp/file.txt")
+
+        Args:
+            source: Source path (local path or pod:path)
+            destination: Destination path (local path or pod:path)
+            namespace: Target namespace
+            container: Container name (optional)
+            context: Kubernetes context to use (optional, uses current context if not specified)
         """
         blocked = check_destructive()
         if blocked:
             return blocked
         try:
-            cmd = ["kubectl", "cp", source, destination, "-n", namespace]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["cp", source, destination, "-n", namespace]
             if container:
                 cmd.extend(["-c", container])
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
             if result.returncode == 0:
-                return {"success": True, "message": f"Copied {source} to {destination}"}
+                return {"success": True, "context": context or "current", "message": f"Copied {source} to {destination}"}
             else:
                 return {"success": False, "error": result.stderr.strip()}
         except Exception as e:
@@ -253,10 +318,17 @@ def register_operations_tools(server, non_destructive: bool):
             readOnlyHint=True,
         ),
     )
-    def backup_resource(resource_type: str, name: str, namespace: Optional[str] = None) -> Dict[str, Any]:
-        """Export a resource as YAML for backup or migration."""
+    def backup_resource(resource_type: str, name: str, namespace: Optional[str] = None, context: str = "") -> Dict[str, Any]:
+        """Export a resource as YAML for backup or migration.
+
+        Args:
+            resource_type: Type of resource to export
+            name: Name of the resource
+            namespace: Target namespace (optional)
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            cmd = ["kubectl", "get", resource_type, name, "-o", "yaml"]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["get", resource_type, name, "-o", "yaml"]
             if namespace:
                 cmd.extend(["-n", namespace])
 
@@ -267,6 +339,7 @@ def register_operations_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "resource": {
                     "type": resource_type,
                     "name": name,
@@ -290,14 +363,24 @@ def register_operations_tools(server, non_destructive: bool):
         name: str,
         labels: Dict[str, str],
         namespace: Optional[str] = None,
-        overwrite: bool = False
+        overwrite: bool = False,
+        context: str = ""
     ) -> Dict[str, Any]:
-        """Add or update labels on a resource."""
+        """Add or update labels on a resource.
+
+        Args:
+            resource_type: Type of resource to label
+            name: Name of the resource
+            labels: Labels to apply (use None value to remove a label)
+            namespace: Target namespace (optional)
+            overwrite: Overwrite existing labels
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         blocked = check_destructive()
         if blocked:
             return blocked
         try:
-            cmd = ["kubectl", "label", resource_type, name]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["label", resource_type, name]
             if namespace:
                 cmd.extend(["-n", namespace])
 
@@ -317,6 +400,7 @@ def register_operations_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "message": result.stdout.strip(),
                 "resource": {"type": resource_type, "name": name, "namespace": namespace},
                 "appliedLabels": labels
@@ -336,14 +420,24 @@ def register_operations_tools(server, non_destructive: bool):
         name: str,
         annotations: Dict[str, str],
         namespace: Optional[str] = None,
-        overwrite: bool = False
+        overwrite: bool = False,
+        context: str = ""
     ) -> Dict[str, Any]:
-        """Add or update annotations on a resource."""
+        """Add or update annotations on a resource.
+
+        Args:
+            resource_type: Type of resource to annotate
+            name: Name of the resource
+            annotations: Annotations to apply (use None value to remove)
+            namespace: Target namespace (optional)
+            overwrite: Overwrite existing annotations
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         blocked = check_destructive()
         if blocked:
             return blocked
         try:
-            cmd = ["kubectl", "annotate", resource_type, name]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["annotate", resource_type, name]
             if namespace:
                 cmd.extend(["-n", namespace])
 
@@ -363,6 +457,7 @@ def register_operations_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "message": result.stdout.strip(),
                 "resource": {"type": resource_type, "name": name, "namespace": namespace},
                 "appliedAnnotations": annotations
@@ -382,9 +477,19 @@ def register_operations_tools(server, non_destructive: bool):
         key: str,
         value: Optional[str] = None,
         effect: str = "NoSchedule",
-        remove: bool = False
+        remove: bool = False,
+        context: str = ""
     ) -> Dict[str, Any]:
-        """Add or remove taints on a node."""
+        """Add or remove taints on a node.
+
+        Args:
+            node_name: Name of the node
+            key: Taint key
+            value: Taint value (optional)
+            effect: Taint effect (NoSchedule, PreferNoSchedule, NoExecute)
+            remove: Remove the taint instead of adding
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         blocked = check_destructive()
         if blocked:
             return blocked
@@ -392,7 +497,7 @@ def register_operations_tools(server, non_destructive: bool):
             if effect not in ["NoSchedule", "PreferNoSchedule", "NoExecute"]:
                 return {"success": False, "error": f"Invalid effect: {effect}. Must be NoSchedule, PreferNoSchedule, or NoExecute"}
 
-            cmd = ["kubectl", "taint", "nodes", node_name]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["taint", "nodes", node_name]
 
             if remove:
                 taint_str = f"{key}:{effect}-"
@@ -411,6 +516,7 @@ def register_operations_tools(server, non_destructive: bool):
 
             return {
                 "success": True,
+                "context": context or "current",
                 "message": result.stdout.strip(),
                 "node": node_name,
                 "action": "removed" if remove else "added",
@@ -431,11 +537,21 @@ def register_operations_tools(server, non_destructive: bool):
         name: str,
         condition: str,
         namespace: Optional[str] = None,
-        timeout: int = 60
+        timeout: int = 60,
+        context: str = ""
     ) -> Dict[str, Any]:
-        """Wait for a resource to reach a specific condition."""
+        """Wait for a resource to reach a specific condition.
+
+        Args:
+            resource_type: Type of resource to wait for
+            name: Name of the resource
+            condition: Condition to wait for (e.g., condition=Ready, delete)
+            namespace: Target namespace (optional)
+            timeout: Timeout in seconds
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         try:
-            cmd = ["kubectl", "wait", f"{resource_type}/{name}", f"--for={condition}", f"--timeout={timeout}s"]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + ["wait", f"{resource_type}/{name}", f"--for={condition}", f"--timeout={timeout}s"]
             if namespace:
                 cmd.extend(["-n", namespace])
 
@@ -446,6 +562,7 @@ def register_operations_tools(server, non_destructive: bool):
                     "success": False,
                     "conditionMet": False,
                     "error": result.stderr.strip(),
+                    "context": context or "current",
                     "resource": {"type": resource_type, "name": name, "namespace": namespace},
                     "condition": condition
                 }
@@ -453,6 +570,7 @@ def register_operations_tools(server, non_destructive: bool):
             return {
                 "success": True,
                 "conditionMet": True,
+                "context": context or "current",
                 "message": result.stdout.strip(),
                 "resource": {"type": resource_type, "name": name, "namespace": namespace},
                 "condition": condition
@@ -462,6 +580,7 @@ def register_operations_tools(server, non_destructive: bool):
                 "success": False,
                 "conditionMet": False,
                 "error": f"Timeout waiting for condition '{condition}' after {timeout}s",
+                "context": context or "current",
                 "resource": {"type": resource_type, "name": name, "namespace": namespace}
             }
         except Exception as e:
@@ -474,8 +593,15 @@ def register_operations_tools(server, non_destructive: bool):
             destructiveHint=True,
         ),
     )
-    def node_management(action: str, node_name: str, force: bool = False) -> Dict[str, Any]:
-        """Manage nodes: cordon, uncordon, or drain."""
+    def node_management(action: str, node_name: str, force: bool = False, context: str = "") -> Dict[str, Any]:
+        """Manage nodes: cordon, uncordon, or drain.
+
+        Args:
+            action: Action to perform (cordon, uncordon, drain)
+            node_name: Name of the node
+            force: Force drain (for drain action)
+            context: Kubernetes context to use (optional, uses current context if not specified)
+        """
         blocked = check_destructive()
         if blocked:
             return blocked
@@ -484,7 +610,7 @@ def register_operations_tools(server, non_destructive: bool):
             if action not in allowed_actions:
                 return {"success": False, "error": f"Invalid action. Allowed: {', '.join(allowed_actions)}"}
 
-            cmd = ["kubectl", action, node_name]
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + [action, node_name]
             if action == "drain":
                 cmd.extend(["--ignore-daemonsets", "--delete-emptydir-data"])
                 if force:
@@ -493,7 +619,7 @@ def register_operations_tools(server, non_destructive: bool):
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
 
             if result.returncode == 0:
-                return {"success": True, "output": result.stdout.strip()}
+                return {"success": True, "context": context or "current", "output": result.stdout.strip()}
             else:
                 return {"success": False, "error": result.stderr.strip()}
         except Exception as e: