kubectl-mcp-server 1.19.0__py3-none-any.whl → 1.19.1__py3-none-any.whl

kubectl_mcp_tool/mcp_server.py

@@ -71,6 +71,7 @@ from kubectl_mcp_tool.tools import (
     register_pod_tools,
     register_core_tools,
     register_cluster_tools,
+    register_multicluster_tools,
     register_deployment_tools,
     register_security_tools,
     register_networking_tools,
@@ -314,6 +315,7 @@ class MCPServer:
         register_pod_tools(self.server, self.non_destructive)
         register_core_tools(self.server, self.non_destructive)
         register_cluster_tools(self.server, self.non_destructive)
+        register_multicluster_tools(self.server, self.non_destructive)
         register_deployment_tools(self.server, self.non_destructive)
         register_security_tools(self.server, self.non_destructive)
         register_networking_tools(self.server, self.non_destructive)
@@ -741,8 +743,36 @@ if __name__ == "__main__":
         action="store_true",
         help="Disable destructive operations (allow create/update, block delete).",
     )
+    parser.add_argument(
+        "--stateless",
+        action="store_true",
+        help="Enable stateless mode (don't cache API clients, reload config each request). Useful for serverless environments.",
+    )
+    parser.add_argument(
+        "--watch-kubeconfig",
+        action="store_true",
+        help="Watch kubeconfig files for changes and auto-reload. Useful when credentials are refreshed externally.",
+    )
+    parser.add_argument(
+        "--watch-interval",
+        type=float,
+        default=5.0,
+        help="Interval in seconds for kubeconfig watch checks. Default: 5.0.",
+    )
     args = parser.parse_args()
 
+    # Configure stateless mode if requested
+    if args.stateless or os.environ.get("MCP_STATELESS_MODE", "").lower() in ("true", "1", "yes"):
+        from kubectl_mcp_tool.k8s_config import set_stateless_mode
+        set_stateless_mode(True)
+        logger.info("Stateless mode enabled via CLI flag")
+
+    # Configure kubeconfig watching if requested
+    if args.watch_kubeconfig or os.environ.get("MCP_KUBECONFIG_WATCH", "").lower() in ("true", "1", "yes"):
+        from kubectl_mcp_tool.k8s_config import enable_kubeconfig_watch
+        enable_kubeconfig_watch(check_interval=args.watch_interval)
+        logger.info(f"Kubeconfig watching enabled (interval: {args.watch_interval}s)")
+
     server_name = "kubectl_mcp_server"
     mcp_server = MCPServer(
         name=server_name,

kubectl_mcp_tool/providers.py

@@ -0,0 +1,347 @@
+import os
+import logging
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple
+from dataclasses import dataclass, field
+from functools import lru_cache
+
+logger = logging.getLogger("mcp-server")
+
+
+class ProviderType(Enum):
+    """Kubernetes provider types."""
+    KUBECONFIG = "kubeconfig"
+    IN_CLUSTER = "in-cluster"
+    SINGLE = "single"
+
+
+class UnknownContextError(Exception):
+    """Raised when a requested context is not found."""
+    def __init__(self, context: str, available: List[str] = None):
+        self.context = context
+        self.available = available or []
+        msg = f"Context '{context}' not found"
+        if self.available:
+            msg += f". Available contexts: {', '.join(self.available)}"
+        super().__init__(msg)
+
+
+class ProviderError(Exception):
+    """Raised when provider configuration is invalid."""
+    pass
+
+
+@dataclass
+class ProviderConfig:
+    """Configuration for Kubernetes provider."""
+    provider_type: ProviderType = ProviderType.KUBECONFIG
+    kubeconfig_path: str = ""
+    context: str = ""
+    qps: float = 100.0
+    burst: int = 200
+    timeout: int = 30
+
+    @classmethod
+    def from_env(cls) -> "ProviderConfig":
+        """Create config from environment variables."""
+        provider_str = os.environ.get("MCP_K8S_PROVIDER", "kubeconfig").lower()
+
+        try:
+            provider_type = ProviderType(provider_str)
+        except ValueError:
+            logger.warning(f"Unknown provider type '{provider_str}', using kubeconfig")
+            provider_type = ProviderType.KUBECONFIG
+
+        kubeconfig_path = os.environ.get(
+            "MCP_K8S_KUBECONFIG",
+            os.environ.get("KUBECONFIG", "~/.kube/config")
+        )
+        kubeconfig_path = os.path.expanduser(kubeconfig_path)
+
+        return cls(
+            provider_type=provider_type,
+            kubeconfig_path=kubeconfig_path,
+            context=os.environ.get("MCP_K8S_CONTEXT", ""),
+            qps=float(os.environ.get("MCP_K8S_QPS", "100")),
+            burst=int(os.environ.get("MCP_K8S_BURST", "200")),
+            timeout=int(os.environ.get("MCP_K8S_TIMEOUT", "30")),
+        )
+
+
+@dataclass
+class ContextInfo:
+    """Information about a kubeconfig context."""
+    name: str
+    cluster: str
+    user: str
+    namespace: str = "default"
+    is_active: bool = False
+
+
+class KubernetesProvider:
+    """
+    Multi-cluster Kubernetes provider.
+
+    Manages connections to multiple Kubernetes clusters based on
+    kubeconfig contexts or in-cluster configuration.
+    """
+
+    _instance: Optional["KubernetesProvider"] = None
+
+    def __init__(self, config: Optional[ProviderConfig] = None):
+        """Initialize provider with configuration."""
+        self.config = config or ProviderConfig.from_env()
+        self._api_clients: Dict[str, Any] = {}
+        self._in_cluster = False
+        self._contexts_cache: Optional[List[ContextInfo]] = None
+        self._active_context: Optional[str] = None
+
+        self._initialize()
+
+    @classmethod
+    def get_instance(cls) -> "KubernetesProvider":
+        """Get singleton provider instance."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls):
+        """Reset singleton instance (for testing)."""
+        cls._instance = None
+
+    def _initialize(self):
+        """Initialize the provider based on type."""
+        if self.config.provider_type == ProviderType.IN_CLUSTER:
+            self._initialize_in_cluster()
+        elif self.config.provider_type == ProviderType.SINGLE:
+            self._initialize_single()
+        else:
+            self._initialize_kubeconfig()
+
+    def _initialize_in_cluster(self):
+        """Initialize for in-cluster provider."""
+        from kubernetes import config
+        from kubernetes.config.config_exception import ConfigException
+
+        try:
+            config.load_incluster_config()
+            self._in_cluster = True
+            self._active_context = "in-cluster"
+            logger.info("Initialized in-cluster Kubernetes provider")
+        except ConfigException as e:
+            raise ProviderError(f"Failed to load in-cluster config: {e}")
+
+    def _initialize_single(self):
+        """Initialize for single-context provider."""
+        if not self.config.context:
+            raise ProviderError("MCP_K8S_CONTEXT must be set for 'single' provider")
+
+        from kubernetes import config
+
+        try:
+            config.load_kube_config(
+                config_file=self.config.kubeconfig_path,
+                context=self.config.context
+            )
+            self._active_context = self.config.context
+            logger.info(f"Initialized single-context provider: {self.config.context}")
+        except Exception as e:
+            raise ProviderError(f"Failed to load context '{self.config.context}': {e}")
+
+    def _initialize_kubeconfig(self):
+        """Initialize for multi-cluster kubeconfig provider."""
+        from kubernetes import config
+
+        try:
+            contexts, active = config.list_kube_config_contexts(
+                config_file=self.config.kubeconfig_path
+            )
+
+            if active:
+                self._active_context = active.get("name")
+
+            self._contexts_cache = [
+                ContextInfo(
+                    name=ctx.get("name", ""),
+                    cluster=ctx.get("context", {}).get("cluster", ""),
+                    user=ctx.get("context", {}).get("user", ""),
+                    namespace=ctx.get("context", {}).get("namespace", "default"),
+                    is_active=ctx.get("name") == self._active_context
+                )
+                for ctx in contexts
+            ]
+
+            logger.info(
+                f"Initialized kubeconfig provider with {len(self._contexts_cache)} contexts, "
+                f"active: {self._active_context}"
+            )
+        except Exception as e:
+            logger.warning(f"Failed to list contexts: {e}")
+            self._contexts_cache = []
+
+    def list_contexts(self) -> List[ContextInfo]:
+        """
+        List all available contexts.
+
+        Returns:
+            List of ContextInfo objects
+        """
+        if self._in_cluster:
+            return [ContextInfo(
+                name="in-cluster",
+                cluster="in-cluster",
+                user="service-account",
+                namespace="default",
+                is_active=True
+            )]
+
+        if self.config.provider_type == ProviderType.SINGLE:
+            from kubernetes import config
+            try:
+                contexts, _ = config.list_kube_config_contexts(
+                    config_file=self.config.kubeconfig_path
+                )
+                for ctx in contexts:
+                    if ctx.get("name") == self.config.context:
+                        return [ContextInfo(
+                            name=ctx.get("name", ""),
+                            cluster=ctx.get("context", {}).get("cluster", ""),
+                            user=ctx.get("context", {}).get("user", ""),
+                            namespace=ctx.get("context", {}).get("namespace", "default"),
+                            is_active=True
+                        )]
+            except Exception:
+                pass
+            return []
+
+        self._refresh_contexts_cache()
+        return self._contexts_cache or []
+
+    def _refresh_contexts_cache(self):
+        """Refresh the contexts cache from kubeconfig."""
+        if self._in_cluster or self.config.provider_type == ProviderType.SINGLE:
+            return
+
+        from kubernetes import config
+        try:
+            contexts, active = config.list_kube_config_contexts(
+                config_file=self.config.kubeconfig_path
+            )
+            self._active_context = active.get("name") if active else None
+            self._contexts_cache = [
+                ContextInfo(
+                    name=ctx.get("name", ""),
+                    cluster=ctx.get("context", {}).get("cluster", ""),
+                    user=ctx.get("context", {}).get("user", ""),
+                    namespace=ctx.get("context", {}).get("namespace", "default"),
+                    is_active=ctx.get("name") == self._active_context
+                )
+                for ctx in contexts
+            ]
+        except Exception as e:
+            logger.warning(f"Failed to refresh contexts: {e}")
+
+    def get_current_context(self) -> Optional[str]:
+        """Get the current active context name."""
+        if self._in_cluster:
+            return "in-cluster"
+        return self._active_context
+
+    def _get_context_names(self) -> List[str]:
+        """Get list of available context names."""
+        contexts = self.list_contexts()
+        return [ctx.name for ctx in contexts]
+
+    def validate_context(self, context: str) -> str:
+        """
+        Validate and resolve a context name.
+
+        Args:
+            context: Context name (empty string uses default)
+
+        Returns:
+            Resolved context name
+
+        Raises:
+            UnknownContextError: If context is not found
+        """
+        if self._in_cluster:
+            return "in-cluster"
+
+        if self.config.provider_type == ProviderType.SINGLE:
+            if context and context != self.config.context:
+                raise UnknownContextError(
+                    context,
+                    [self.config.context]
+                )
+            return self.config.context
+
+        if not context:
+            return self._active_context or ""
+
+        available = self._get_context_names()
+        if context not in available:
+            raise UnknownContextError(context, available)
+
+        return context
+
+    def get_api_client(self, context: str = "") -> Any:
+        """
+        Get an API client configuration for a specific context.
+
+        Args:
+            context: Context name (empty uses default)
+
+        Returns:
+            kubernetes.client.ApiClient configured for the context
+        """
+        from kubernetes import client, config
+
+        resolved_context = self.validate_context(context)
+
+        if resolved_context in self._api_clients:
+            return self._api_clients[resolved_context]
+
+        if self._in_cluster:
+            api_client = client.ApiClient()
+        else:
+            api_config = client.Configuration()
+            config.load_kube_config(
+                config_file=self.config.kubeconfig_path,
+                context=resolved_context,
+                client_configuration=api_config
+            )
+            api_client = client.ApiClient(configuration=api_config)
+
+        self._api_clients[resolved_context] = api_client
+
+        return api_client
+
+    def clear_client_cache(self, context: str = ""):
+        """Clear cached API client(s)."""
+        if context:
+            self._api_clients.pop(context, None)
+        else:
+            self._api_clients.clear()
+
+
+def get_provider() -> KubernetesProvider:
+    """Get the global Kubernetes provider instance."""
+    return KubernetesProvider.get_instance()
+
+
+def get_context_names() -> List[str]:
+    """Get list of available context names."""
+    provider = get_provider()
+    return [ctx.name for ctx in provider.list_contexts()]
+
+
+def get_current_context() -> Optional[str]:
+    """Get the current active context name."""
+    return get_provider().get_current_context()
+
+
+def validate_context(context: str) -> str:
+    """Validate and resolve a context name."""
+    return get_provider().validate_context(context)

kubectl_mcp_tool/tools/__init__.py

@@ -1,7 +1,7 @@
 from .helm import register_helm_tools
 from .pods import register_pod_tools
 from .core import register_core_tools
-from .cluster import register_cluster_tools
+from .cluster import register_cluster_tools, register_multicluster_tools
 from .deployments import register_deployment_tools
 from .security import register_security_tools
 from .networking import register_networking_tools
@@ -27,6 +27,7 @@ __all__ = [
     "register_pod_tools",
     "register_core_tools",
     "register_cluster_tools",
+    "register_multicluster_tools",
     "register_deployment_tools",
     "register_security_tools",
     "register_networking_tools",

kubectl_mcp_tool/tools/backup.py

@@ -1,11 +1,8 @@
-"""Backup toolset for kubectl-mcp-server.
-
-Provides tools for managing Velero backups and restores.
-"""
+"""Backup toolset for kubectl-mcp-server (Velero backups and restores)."""
 
 import subprocess
 import json
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List
 from datetime import datetime
 
 try:
@@ -15,8 +12,8 @@ except ImportError:
     from mcp.server.fastmcp import FastMCP
     from mcp.types import ToolAnnotations
 
-from ..k8s_config import _get_kubectl_context_args
 from ..crd_detector import crd_exists
+from .utils import run_kubectl, get_resources
 
 
 VELERO_BACKUP_CRD = "backups.velero.io"
@@ -26,40 +23,6 @@ VELERO_BSL_CRD = "backupstoragelocations.velero.io"
 VELERO_VSL_CRD = "volumesnapshotlocations.velero.io"
 
 
-def _run_kubectl(args: List[str], context: str = "") -> Dict[str, Any]:
-    """Run kubectl command and return result."""
-    cmd = ["kubectl"] + _get_kubectl_context_args(context) + args
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-        if result.returncode == 0:
-            return {"success": True, "output": result.stdout}
-        return {"success": False, "error": result.stderr}
-    except subprocess.TimeoutExpired:
-        return {"success": False, "error": "Command timed out"}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-def _get_resources(kind: str, namespace: str = "", context: str = "", label_selector: str = "") -> List[Dict]:
-    """Get Kubernetes resources of a specific kind."""
-    args = ["get", kind, "-o", "json"]
-    if namespace:
-        args.extend(["-n", namespace])
-    else:
-        args.append("-A")
-    if label_selector:
-        args.extend(["-l", label_selector])
-
-    result = _run_kubectl(args, context)
-    if result["success"]:
-        try:
-            data = json.loads(result["output"])
-            return data.get("items", [])
-        except json.JSONDecodeError:
-            return []
-    return []
-
-
 def _velero_cli_available() -> bool:
     """Check if velero CLI is available."""
     try:
@@ -112,7 +75,7 @@ def backup_list(
         }
 
     backups = []
-    for item in _get_resources("backups.velero.io", namespace, context, label_selector):
+    for item in get_resources("backups.velero.io", namespace, context, label_selector):
         status = item.get("status", {})
         spec = item.get("spec", {})
         progress = status.get("progress", {})
@@ -165,7 +128,7 @@ def backup_get(
         return {"success": False, "error": "Velero is not installed"}
 
     args = ["get", "backups.velero.io", name, "-n", namespace, "-o", "json"]
-    result = _run_kubectl(args, context)
+    result = run_kubectl(args, context)
 
     if result["success"]:
         try:
@@ -341,7 +304,7 @@ def backup_delete(
         return result
 
     args = ["delete", "backups.velero.io", name, "-n", namespace]
-    result = _run_kubectl(args, context)
+    result = run_kubectl(args, context)
 
     if result["success"]:
         return {
@@ -375,7 +338,7 @@ def restore_list(
         }
 
     restores = []
-    for item in _get_resources("restores.velero.io", namespace, context, label_selector):
+    for item in get_resources("restores.velero.io", namespace, context, label_selector):
         status = item.get("status", {})
         spec = item.get("spec", {})
         progress = status.get("progress", {})
@@ -536,7 +499,7 @@ def restore_get(
         return {"success": False, "error": "Velero is not installed"}
 
     args = ["get", "restores.velero.io", name, "-n", namespace, "-o", "json"]
-    result = _run_kubectl(args, context)
+    result = run_kubectl(args, context)
 
     if result["success"]:
         try:
@@ -572,7 +535,7 @@ def backup_locations_list(
         }
 
     locations = []
-    for item in _get_resources("backupstoragelocations.velero.io", namespace, context):
+    for item in get_resources("backupstoragelocations.velero.io", namespace, context):
         status = item.get("status", {})
         spec = item.get("spec", {})
 
@@ -615,7 +578,7 @@ def backup_schedules_list(
         }
 
     schedules = []
-    for item in _get_resources("schedules.velero.io", namespace, context):
+    for item in get_resources("schedules.velero.io", namespace, context):
         status = item.get("status", {})
         spec = item.get("spec", {})
         template = spec.get("template", {})