kubectl-mcp-server 1.12.0__py3-none-any.whl

kubectl_mcp_tool/tools/browser.py

@@ -0,0 +1,371 @@
+"""Browser automation tools using agent-browser (optional module)."""
+
+import json
+import logging
+import os
+import shutil
+import subprocess
+from typing import Any, Dict, Optional
+
+from mcp.types import ToolAnnotations
+
+logger = logging.getLogger("mcp-server")
+
+BROWSER_ENABLED = os.environ.get("MCP_BROWSER_ENABLED", "").lower() in ("1", "true")
+BROWSER_AVAILABLE = shutil.which("agent-browser") is not None
+
+
+def is_browser_available() -> bool:
+    """Check if browser tools should be registered."""
+    if not BROWSER_ENABLED:
+        return False
+    if not BROWSER_AVAILABLE:
+        logger.warning("MCP_BROWSER_ENABLED=true but agent-browser not found in PATH")
+        return False
+    return True
+
+
+def _run_browser(args: list, timeout: int = 60) -> Dict[str, Any]:
+    """Execute agent-browser command."""
+    cmd = ["agent-browser"] + args
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+        if result.returncode != 0:
+            return {"success": False, "error": result.stderr.strip() or "Command failed"}
+        output = result.stdout.strip()
+        if "--json" in args:
+            try:
+                return {"success": True, "data": json.loads(output)}
+            except json.JSONDecodeError:
+                return {"success": True, "output": output}
+        return {"success": True, "output": output}
+    except subprocess.TimeoutExpired:
+        return {"success": False, "error": f"Command timed out after {timeout}s"}
+    except FileNotFoundError:
+        return {"success": False, "error": "agent-browser not found"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def _get_ingress_url(service: str, namespace: str) -> Optional[str]:
+    """Get ingress URL for a service."""
+    try:
+        from kubernetes import client, config
+        config.load_kube_config()
+        networking = client.NetworkingV1Api()
+        ingresses = networking.list_namespaced_ingress(namespace)
+        for ing in ingresses.items:
+            for rule in ing.spec.rules or []:
+                for path in (rule.http.paths if rule.http else []):
+                    backend = path.backend
+                    if backend.service and backend.service.name == service:
+                        host = rule.host or ing.status.load_balancer.ingress[0].hostname
+                        scheme = "https" if ing.spec.tls else "http"
+                        return f"{scheme}://{host}"
+        return None
+    except Exception:
+        return None
+
+
+def _get_service_url(service: str, namespace: str) -> Optional[str]:
+    """Get service URL (LoadBalancer or NodePort)."""
+    try:
+        from kubernetes import client, config
+        config.load_kube_config()
+        v1 = client.CoreV1Api()
+        svc = v1.read_namespaced_service(service, namespace)
+        if svc.spec.type == "LoadBalancer":
+            ingress = svc.status.load_balancer.ingress
+            if ingress:
+                host = ingress[0].hostname or ingress[0].ip
+                port = svc.spec.ports[0].port
+                return f"http://{host}:{port}"
+        elif svc.spec.type == "NodePort":
+            node_port = svc.spec.ports[0].node_port
+            return f"http://localhost:{node_port}"
+        return None
+    except Exception:
+        return None
+
+
+def register_browser_tools(server, non_destructive: bool):
+    """Register browser automation tools."""
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Open URL", readOnlyHint=True))
+    def browser_open(url: str, wait_for: str = "networkidle") -> Dict[str, Any]:
+        """Open a URL in the browser."""
+        result = _run_browser(["open", url])
+        if result.get("success") and wait_for:
+            _run_browser(["wait", "--load", wait_for])
+        return {**result, "url": url}
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Snapshot", readOnlyHint=True))
+    def browser_snapshot(interactive_only: bool = True, compact: bool = True, depth: Optional[int] = None) -> Dict[str, Any]:
+        """Get accessibility tree snapshot of current page."""
+        args = ["snapshot", "--json"]
+        if interactive_only:
+            args.append("-i")
+        if compact:
+            args.append("-c")
+        if depth:
+            args.extend(["-d", str(depth)])
+        return _run_browser(args)
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Click"))
+    def browser_click(ref: str) -> Dict[str, Any]:
+        """Click an element by ref (from snapshot)."""
+        return _run_browser(["click", ref])
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Fill"))
+    def browser_fill(ref: str, text: str) -> Dict[str, Any]:
+        """Fill a form field by ref."""
+        return _run_browser(["fill", ref, text])
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Screenshot", readOnlyHint=True))
+    def browser_screenshot(output_path: str = "/tmp/screenshot.png", full_page: bool = False) -> Dict[str, Any]:
+        """Take a screenshot of the current page."""
+        args = ["screenshot", output_path]
+        if full_page:
+            args.append("--full")
+        result = _run_browser(args)
+        return {**result, "path": output_path}
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Get Text", readOnlyHint=True))
+    def browser_get_text(ref: str) -> Dict[str, Any]:
+        """Get text content of an element."""
+        return _run_browser(["get", "text", ref])
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Get URL", readOnlyHint=True))
+    def browser_get_url() -> Dict[str, Any]:
+        """Get current page URL."""
+        return _run_browser(["get", "url"])
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Wait"))
+    def browser_wait(selector: Optional[str] = None, text: Optional[str] = None, timeout_ms: int = 5000) -> Dict[str, Any]:
+        """Wait for element, text, or timeout."""
+        if text:
+            return _run_browser(["wait", "--text", text], timeout=timeout_ms // 1000 + 5)
+        elif selector:
+            return _run_browser(["wait", selector], timeout=timeout_ms // 1000 + 5)
+        else:
+            return _run_browser(["wait", str(timeout_ms)])
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Close"))
+    def browser_close() -> Dict[str, Any]:
+        """Close the browser."""
+        return _run_browser(["close"])
+
+    @server.tool(annotations=ToolAnnotations(title="Test K8s Ingress", readOnlyHint=True))
+    def browser_test_ingress(
+        service_name: str,
+        namespace: str = "default",
+        path: str = "/",
+        expected_text: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Test a Kubernetes service via its Ingress URL."""
+        url = _get_ingress_url(service_name, namespace)
+        if not url:
+            url = _get_service_url(service_name, namespace)
+        if not url:
+            return {"success": False, "error": f"No external URL found for {service_name} in {namespace}"}
+
+        full_url = f"{url}{path}"
+        open_result = _run_browser(["open", full_url])
+        if not open_result.get("success"):
+            return {**open_result, "url": full_url}
+
+        _run_browser(["wait", "--load", "networkidle"])
+        snapshot = _run_browser(["snapshot", "-i", "--json"])
+
+        result = {
+            "success": True,
+            "url": full_url,
+            "service": service_name,
+            "namespace": namespace,
+            "accessible": True,
+            "snapshot": snapshot.get("data")
+        }
+
+        if expected_text:
+            text_result = _run_browser(["wait", "--text", expected_text], timeout=10)
+            result["expectedTextFound"] = text_result.get("success", False)
+
+        _run_browser(["close"])
+        return result
+
+    @server.tool(annotations=ToolAnnotations(title="Screenshot K8s Service", readOnlyHint=True))
+    def browser_screenshot_service(
+        service_name: str,
+        namespace: str = "default",
+        path: str = "/",
+        output_path: str = "/tmp/service-screenshot.png",
+        full_page: bool = True
+    ) -> Dict[str, Any]:
+        """Take a screenshot of a Kubernetes service's web UI."""
+        url = _get_ingress_url(service_name, namespace)
+        if not url:
+            url = _get_service_url(service_name, namespace)
+        if not url:
+            return {"success": False, "error": f"No external URL found for {service_name} in {namespace}"}
+
+        full_url = f"{url}{path}"
+        _run_browser(["open", full_url])
+        _run_browser(["wait", "--load", "networkidle"])
+        _run_browser(["wait", "2000"])
+
+        args = ["screenshot", output_path]
+        if full_page:
+            args.append("--full")
+        result = _run_browser(args)
+        _run_browser(["close"])
+        return {**result, "url": full_url, "path": output_path}
+
+    @server.tool(annotations=ToolAnnotations(title="Screenshot Grafana", readOnlyHint=True))
+    def browser_screenshot_grafana(
+        grafana_url: str,
+        dashboard_uid: Optional[str] = None,
+        output_path: str = "/tmp/grafana-dashboard.png"
+    ) -> Dict[str, Any]:
+        """Take a screenshot of a Grafana dashboard."""
+        url = grafana_url
+        if dashboard_uid:
+            url = f"{grafana_url.rstrip('/')}/d/{dashboard_uid}"
+
+        _run_browser(["open", url])
+        _run_browser(["wait", "--load", "networkidle"])
+        _run_browser(["wait", "3000"])
+        result = _run_browser(["screenshot", "--full", output_path])
+        _run_browser(["close"])
+        return {**result, "url": url, "path": output_path}
+
+    @server.tool(annotations=ToolAnnotations(title="Screenshot ArgoCD", readOnlyHint=True))
+    def browser_screenshot_argocd(
+        argocd_url: str,
+        app_name: Optional[str] = None,
+        output_path: str = "/tmp/argocd-screenshot.png"
+    ) -> Dict[str, Any]:
+        """Take a screenshot of ArgoCD application view."""
+        url = argocd_url
+        if app_name:
+            url = f"{argocd_url.rstrip('/')}/applications/{app_name}"
+
+        _run_browser(["open", url])
+        _run_browser(["wait", "--load", "networkidle"])
+        _run_browser(["wait", "2000"])
+        result = _run_browser(["screenshot", "--full", output_path])
+        _run_browser(["close"])
+        return {**result, "url": url, "path": output_path}
+
+    @server.tool(annotations=ToolAnnotations(title="Health Check Web App", readOnlyHint=True))
+    def browser_health_check(
+        url: str,
+        expected_status_text: Optional[str] = None,
+        check_elements: Optional[list] = None
+    ) -> Dict[str, Any]:
+        """Perform health check on a web application."""
+        open_result = _run_browser(["open", url])
+        if not open_result.get("success"):
+            return {**open_result, "url": url, "healthy": False}
+
+        _run_browser(["wait", "--load", "networkidle"])
+        title_result = _run_browser(["get", "title"])
+        url_result = _run_browser(["get", "url"])
+        snapshot = _run_browser(["snapshot", "-i", "-c", "--json"])
+
+        result = {
+            "success": True,
+            "url": url,
+            "finalUrl": url_result.get("output"),
+            "title": title_result.get("output"),
+            "healthy": True,
+            "checks": {}
+        }
+
+        if expected_status_text:
+            text_check = _run_browser(["wait", "--text", expected_status_text], timeout=5)
+            result["checks"]["expectedText"] = text_check.get("success", False)
+            if not text_check.get("success"):
+                result["healthy"] = False
+
+        if check_elements:
+            for elem in check_elements:
+                elem_check = _run_browser(["is", "visible", elem])
+                result["checks"][elem] = "visible" in elem_check.get("output", "").lower()
+
+        _run_browser(["close"])
+        return result
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Form Submit"))
+    def browser_form_submit(
+        url: str,
+        form_data: Dict[str, str],
+        submit_ref: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Fill and submit a web form."""
+        _run_browser(["open", url])
+        _run_browser(["wait", "--load", "networkidle"])
+
+        for ref, value in form_data.items():
+            fill_result = _run_browser(["fill", ref, value])
+            if not fill_result.get("success"):
+                _run_browser(["close"])
+                return {"success": False, "error": f"Failed to fill {ref}", "details": fill_result}
+
+        if submit_ref:
+            _run_browser(["click", submit_ref])
+            _run_browser(["wait", "--load", "networkidle"])
+
+        snapshot = _run_browser(["snapshot", "-i", "--json"])
+        final_url = _run_browser(["get", "url"])
+        _run_browser(["close"])
+
+        return {
+            "success": True,
+            "url": url,
+            "finalUrl": final_url.get("output"),
+            "formData": list(form_data.keys()),
+            "snapshot": snapshot.get("data")
+        }
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Session Save"))
+    def browser_session_save(path: str = "/tmp/browser-state.json") -> Dict[str, Any]:
+        """Save browser session state (cookies, storage)."""
+        return _run_browser(["state", "save", path])
+
+    @server.tool(annotations=ToolAnnotations(title="Browser Session Load"))
+    def browser_session_load(path: str = "/tmp/browser-state.json") -> Dict[str, Any]:
+        """Load browser session state."""
+        return _run_browser(["state", "load", path])
+
+    @server.tool(annotations=ToolAnnotations(title="Open Cloud Console", readOnlyHint=True))
+    def browser_open_cloud_console(
+        provider: str,
+        resource_type: str = "clusters",
+        region: Optional[str] = None,
+        project: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Open cloud provider Kubernetes console (eks, gke, aks)."""
+        urls = {
+            "eks": f"https://{region or 'us-east-1'}.console.aws.amazon.com/eks/home?region={region or 'us-east-1'}#/{resource_type}",
+            "gke": f"https://console.cloud.google.com/kubernetes/{resource_type}?project={project or '_'}",
+            "aks": "https://portal.azure.com/#browse/Microsoft.ContainerService%2FmanagedClusters",
+            "do": "https://cloud.digitalocean.com/kubernetes/clusters",
+        }
+        url = urls.get(provider.lower())
+        if not url:
+            return {"success": False, "error": f"Unknown provider: {provider}. Use eks, gke, aks, or do"}
+
+        result = _run_browser(["open", url])
+        return {**result, "provider": provider, "url": url}
+
+    @server.tool(annotations=ToolAnnotations(title="Browser PDF Export", readOnlyHint=True))
+    def browser_pdf_export(url: str, output_path: str = "/tmp/page.pdf") -> Dict[str, Any]:
+        """Export a web page as PDF."""
+        _run_browser(["open", url])
+        _run_browser(["wait", "--load", "networkidle"])
+        _run_browser(["wait", "2000"])
+        result = _run_browser(["pdf", output_path])
+        _run_browser(["close"])
+        return {**result, "url": url, "path": output_path}
+
+    logger.info("Registered 19 browser automation tools")

kubectl_mcp_tool/tools/cluster.py

@@ -0,0 +1,315 @@
+import logging
+import subprocess
+from typing import Any, Dict, Optional
+
+from mcp.types import ToolAnnotations
+
+logger = logging.getLogger("mcp-server")
+
+
+def register_cluster_tools(server, non_destructive: bool):
+    """Register cluster and context management tools."""
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Switch Context",
+            destructiveHint=True,
+        ),
+    )
+    def switch_context(context_name: str) -> Dict[str, Any]:
+        """Switch to a different kubectl context."""
+        try:
+            result = subprocess.run(
+                ["kubectl", "config", "use-context", context_name],
+                capture_output=True, text=True, timeout=10
+            )
+            if result.returncode == 0:
+                return {"success": True, "message": f"Switched to context: {context_name}"}
+            return {"success": False, "error": result.stderr}
+        except Exception as e:
+            logger.error(f"Error switching context: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Get Current Context",
+            readOnlyHint=True,
+        ),
+    )
+    def get_current_context() -> Dict[str, Any]:
+        """Get the current kubectl context."""
+        try:
+            result = subprocess.run(
+                ["kubectl", "config", "current-context"],
+                capture_output=True, text=True, timeout=10
+            )
+            if result.returncode == 0:
+                return {"success": True, "context": result.stdout.strip()}
+            return {"success": False, "error": result.stderr}
+        except Exception as e:
+            logger.error(f"Error getting current context: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="List Contexts",
+            readOnlyHint=True,
+        ),
+    )
+    def list_contexts() -> Dict[str, Any]:
+        """List all available kubectl contexts."""
+        try:
+            from kubernetes import config
+            contexts, active_context = config.list_kube_config_contexts()
+            return {
+                "success": True,
+                "contexts": [
+                    {
+                        "name": ctx.get("name"),
+                        "cluster": ctx.get("context", {}).get("cluster"),
+                        "user": ctx.get("context", {}).get("user"),
+                        "namespace": ctx.get("context", {}).get("namespace", "default"),
+                        "active": ctx.get("name") == (active_context.get("name") if active_context else None)
+                    }
+                    for ctx in contexts
+                ],
+                "active_context": active_context.get("name") if active_context else None
+            }
+        except Exception as e:
+            logger.error(f"Error listing contexts: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Get Context Details",
+            readOnlyHint=True,
+        ),
+    )
+    def get_context_details(context_name: str) -> Dict[str, Any]:
+        """Get details about a specific context."""
+        try:
+            from kubernetes import config
+            contexts, _ = config.list_kube_config_contexts()
+
+            for ctx in contexts:
+                if ctx.get("name") == context_name:
+                    return {
+                        "success": True,
+                        "context": {
+                            "name": ctx.get("name"),
+                            "cluster": ctx.get("context", {}).get("cluster"),
+                            "user": ctx.get("context", {}).get("user"),
+                            "namespace": ctx.get("context", {}).get("namespace", "default")
+                        }
+                    }
+
+            return {"success": False, "error": f"Context '{context_name}' not found"}
+        except Exception as e:
+            logger.error(f"Error getting context details: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Set Namespace for Context",
+            destructiveHint=True,
+        ),
+    )
+    def set_namespace_for_context(namespace: str, context_name: Optional[str] = None) -> Dict[str, Any]:
+        """Set the default namespace for a context."""
+        try:
+            cmd = ["kubectl", "config", "set-context"]
+            if context_name:
+                cmd.append(context_name)
+            else:
+                cmd.append("--current")
+            cmd.extend(["--namespace", namespace])
+
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+            if result.returncode == 0:
+                return {"success": True, "message": f"Namespace set to: {namespace}"}
+            return {"success": False, "error": result.stderr}
+        except Exception as e:
+            logger.error(f"Error setting namespace: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="List Kubeconfig Contexts",
+            readOnlyHint=True,
+        ),
+    )
+    def list_kubeconfig_contexts() -> Dict[str, Any]:
+        """List all contexts from kubeconfig with detailed info."""
+        try:
+            result = subprocess.run(
+                ["kubectl", "config", "get-contexts", "-o", "name"],
+                capture_output=True, text=True, timeout=10
+            )
+            if result.returncode == 0:
+                contexts = [c.strip() for c in result.stdout.strip().split("\n") if c.strip()]
+                return {"success": True, "contexts": contexts}
+            return {"success": False, "error": result.stderr}
+        except Exception as e:
+            logger.error(f"Error listing kubeconfig contexts: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Get Cluster Info",
+            readOnlyHint=True,
+        ),
+    )
+    def get_cluster_info() -> Dict[str, Any]:
+        """Get cluster information."""
+        try:
+            result = subprocess.run(
+                ["kubectl", "cluster-info"],
+                capture_output=True, text=True, timeout=30
+            )
+            if result.returncode == 0:
+                return {"success": True, "info": result.stdout}
+            return {"success": False, "error": result.stderr}
+        except Exception as e:
+            logger.error(f"Error getting cluster info: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Kubectl Explain",
+            readOnlyHint=True,
+        ),
+    )
+    def kubectl_explain(resource: str) -> Dict[str, Any]:
+        """Explain a Kubernetes resource."""
+        try:
+            result = subprocess.run(
+                ["kubectl", "explain", resource],
+                capture_output=True, text=True, timeout=30
+            )
+            return {"success": result.returncode == 0, "output": result.stdout or result.stderr}
+        except Exception as e:
+            logger.error(f"Error explaining resource: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Get API Resources",
+            readOnlyHint=True,
+        ),
+    )
+    def get_api_resources() -> Dict[str, Any]:
+        """Get available API resources."""
+        try:
+            result = subprocess.run(
+                ["kubectl", "api-resources"],
+                capture_output=True, text=True, timeout=30
+            )
+            return {"success": result.returncode == 0, "output": result.stdout or result.stderr}
+        except Exception as e:
+            logger.error(f"Error getting API resources: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Health Check",
+            readOnlyHint=True,
+        ),
+    )
+    def health_check() -> Dict[str, Any]:
+        """Perform a cluster health check."""
+        try:
+            result = subprocess.run(
+                ["kubectl", "get", "componentstatuses", "-o", "json"],
+                capture_output=True, text=True, timeout=30
+            )
+            if result.returncode == 0:
+                import json
+                data = json.loads(result.stdout)
+                return {"success": True, "components": data.get("items", [])}
+            return {"success": False, "error": result.stderr}
+        except Exception as e:
+            logger.error(f"Error performing health check: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Get Cluster Version Info",
+            readOnlyHint=True,
+        ),
+    )
+    def get_cluster_version() -> Dict[str, Any]:
+        """Get Kubernetes cluster version information."""
+        try:
+            from kubernetes import client, config
+            config.load_kube_config()
+            version_api = client.VersionApi()
+            version_info = version_api.get_code()
+
+            return {
+                "success": True,
+                "version": {
+                    "gitVersion": version_info.git_version,
+                    "major": version_info.major,
+                    "minor": version_info.minor,
+                    "platform": version_info.platform,
+                    "buildDate": version_info.build_date,
+                    "goVersion": version_info.go_version,
+                    "compiler": version_info.compiler
+                }
+            }
+        except Exception as e:
+            logger.error(f"Error getting cluster version: {e}")
+            return {"success": False, "error": str(e)}
+
+    @server.tool(
+        annotations=ToolAnnotations(
+            title="Get Admission Webhooks",
+            readOnlyHint=True,
+        ),
+    )
+    def get_admission_webhooks() -> Dict[str, Any]:
+        """Get admission webhooks configured in the cluster."""
+        try:
+            from kubernetes import client, config
+            config.load_kube_config()
+            api = client.AdmissionregistrationV1Api()
+
+            validating = api.list_validating_webhook_configuration()
+            mutating = api.list_mutating_webhook_configuration()
+
+            return {
+                "success": True,
+                "validatingWebhooks": [
+                    {
+                        "name": w.metadata.name,
+                        "webhooks": [
+                            {
+                                "name": wh.name,
+                                "failurePolicy": wh.failure_policy,
+                                "matchPolicy": wh.match_policy,
+                                "sideEffects": wh.side_effects
+                            }
+                            for wh in (w.webhooks or [])
+                        ]
+                    }
+                    for w in validating.items
+                ],
+                "mutatingWebhooks": [
+                    {
+                        "name": w.metadata.name,
+                        "webhooks": [
+                            {
+                                "name": wh.name,
+                                "failurePolicy": wh.failure_policy,
+                                "matchPolicy": wh.match_policy,
+                                "sideEffects": wh.side_effects
+                            }
+                            for wh in (w.webhooks or [])
+                        ]
+                    }
+                    for w in mutating.items
+                ]
+            }
+        except Exception as e:
+            logger.error(f"Error getting admission webhooks: {e}")
+            return {"success": False, "error": str(e)}