kubectl-mcp-server 1.14.0__py3-none-any.whl → 1.16.0__py3-none-any.whl

kubectl_mcp_tool/k8s_config.py

@@ -2,13 +2,15 @@
 Kubernetes configuration loader utility.
 
 Handles both in-cluster and out-of-cluster (kubeconfig) configurations.
+Supports multi-cluster operations with context targeting.
 
-This module patches the kubernetes.config.load_kube_config function to
-automatically try in-cluster config first when running inside a pod.
+This module provides context-aware client creation for multi-cluster support.
+All get_*_client() functions accept an optional 'context' parameter.
 """
 
 import os
 import logging
+from typing import Optional, Any
 
 logger = logging.getLogger("mcp-server")
 
@@ -16,20 +18,20 @@ _config_loaded = False
 _original_load_kube_config = None
 
 
-def load_kubernetes_config():
+def load_kubernetes_config(context: str = ""):
     """Load Kubernetes configuration.
 
     Tries in-cluster config first (when running inside a pod),
     then falls back to kubeconfig file.
 
+    Args:
+        context: Optional context name for kubeconfig provider
+
     Returns:
         bool: True if config loaded successfully, False otherwise
     """
     global _config_loaded
 
-    if _config_loaded:
-        return True
-
     from kubernetes import config
     from kubernetes.config.config_exception import ConfigException
 
@@ -46,8 +48,14 @@ def load_kubernetes_config():
     try:
         kubeconfig_path = os.environ.get('KUBECONFIG', '~/.kube/config')
         kubeconfig_path = os.path.expanduser(kubeconfig_path)
-        config.load_kube_config(config_file=kubeconfig_path)
-        logger.info(f"Loaded kubeconfig from {kubeconfig_path}")
+
+        if context:
+            config.load_kube_config(config_file=kubeconfig_path, context=context)
+            logger.info(f"Loaded kubeconfig context '{context}' from {kubeconfig_path}")
+        else:
+            config.load_kube_config(config_file=kubeconfig_path)
+            logger.info(f"Loaded kubeconfig from {kubeconfig_path}")
+
         _config_loaded = True
         return True
     except ConfigException as e:
@@ -102,8 +110,52 @@ def patch_kubernetes_config():
 patch_kubernetes_config()
 
 
-def get_k8s_client():
-    """Get a configured Kubernetes API client.
+def _load_config_for_context(context: str = "") -> Any:
+    """
+    Load kubernetes config for a specific context and return ApiClient.
+
+    Args:
+        context: Context name (empty for default)
+
+    Returns:
+        kubernetes.client.ApiClient configured for the context
+    """
+    from kubernetes import client, config
+    from kubernetes.config.config_exception import ConfigException
+
+    # Try in-cluster first
+    try:
+        config.load_incluster_config()
+        return client.ApiClient()
+    except ConfigException:
+        pass
+
+    # Load kubeconfig with optional context
+    kubeconfig_path = os.environ.get('KUBECONFIG', '~/.kube/config')
+    kubeconfig_path = os.path.expanduser(kubeconfig_path)
+
+    api_config = client.Configuration()
+
+    if context:
+        config.load_kube_config(
+            config_file=kubeconfig_path,
+            context=context,
+            client_configuration=api_config
+        )
+    else:
+        config.load_kube_config(
+            config_file=kubeconfig_path,
+            client_configuration=api_config
+        )
+
+    return client.ApiClient(configuration=api_config)
+
+
+def get_k8s_client(context: str = ""):
+    """Get a configured Kubernetes Core API client.
+
+    Args:
+        context: Optional context name for multi-cluster support
 
     Returns:
         kubernetes.client.CoreV1Api: Configured Kubernetes client
@@ -113,15 +165,19 @@ def get_k8s_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.CoreV1Api()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.CoreV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_apps_client():
+def get_apps_client(context: str = ""):
     """Get a configured Kubernetes Apps API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.AppsV1Api: Configured Apps API client
 
@@ -130,15 +186,19 @@ def get_apps_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.AppsV1Api()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.AppsV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_rbac_client():
+def get_rbac_client(context: str = ""):
     """Get a configured Kubernetes RBAC API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.RbacAuthorizationV1Api: Configured RBAC client
 
@@ -147,15 +207,19 @@ def get_rbac_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.RbacAuthorizationV1Api()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.RbacAuthorizationV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_networking_client():
+def get_networking_client(context: str = ""):
     """Get a configured Kubernetes Networking API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.NetworkingV1Api: Configured Networking client
 
@@ -164,15 +228,19 @@ def get_networking_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.NetworkingV1Api()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.NetworkingV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_storage_client():
+def get_storage_client(context: str = ""):
     """Get a configured Kubernetes Storage API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.StorageV1Api: Configured Storage client
 
@@ -181,15 +249,19 @@ def get_storage_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.StorageV1Api()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.StorageV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_batch_client():
+def get_batch_client(context: str = ""):
     """Get a configured Kubernetes Batch API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.BatchV1Api: Configured Batch client
 
@@ -198,15 +270,19 @@ def get_batch_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.BatchV1Api()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.BatchV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_autoscaling_client():
+def get_autoscaling_client(context: str = ""):
     """Get a configured Kubernetes Autoscaling API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.AutoscalingV1Api: Configured Autoscaling client
 
@@ -215,15 +291,19 @@ def get_autoscaling_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.AutoscalingV1Api()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.AutoscalingV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_policy_client():
+def get_policy_client(context: str = ""):
     """Get a configured Kubernetes Policy API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.PolicyV1Api: Configured Policy client
 
@@ -232,15 +312,19 @@ def get_policy_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.PolicyV1Api()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.PolicyV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_custom_objects_client():
+def get_custom_objects_client(context: str = ""):
     """Get a configured Kubernetes Custom Objects API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.CustomObjectsApi: Configured Custom Objects client
 
@@ -249,15 +333,19 @@ def get_custom_objects_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.CustomObjectsApi()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.CustomObjectsApi(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_version_client():
+def get_version_client(context: str = ""):
     """Get a configured Kubernetes Version API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.VersionApi: Configured Version client
 
@@ -266,15 +354,19 @@ def get_version_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
-
-    return client.VersionApi()
+    try:
+        api_client = _load_config_for_context(context)
+        return client.VersionApi(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
 
 
-def get_admissionregistration_client():
+def get_admissionregistration_client(context: str = ""):
     """Get a configured Kubernetes Admission Registration API client.
 
+    Args:
+        context: Optional context name for multi-cluster support
+
     Returns:
         kubernetes.client.AdmissionregistrationV1Api: Configured Admission client
 
@@ -283,7 +375,156 @@ def get_admissionregistration_client():
     """
     from kubernetes import client
 
-    if not load_kubernetes_config():
-        raise RuntimeError("Invalid kube-config file. No configuration found.")
+    try:
+        api_client = _load_config_for_context(context)
+        return client.AdmissionregistrationV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
+
+
+def get_apiextensions_client(context: str = ""):
+    """Get a configured Kubernetes API Extensions client.
+
+    Args:
+        context: Optional context name for multi-cluster support
 
-    return client.AdmissionregistrationV1Api()
+    Returns:
+        kubernetes.client.ApiextensionsV1Api: Configured API Extensions client
+
+    Raises:
+        RuntimeError: If Kubernetes config cannot be loaded
+    """
+    from kubernetes import client
+
+    try:
+        api_client = _load_config_for_context(context)
+        return client.ApiextensionsV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
+
+
+def get_coordination_client(context: str = ""):
+    """Get a configured Kubernetes Coordination API client.
+
+    Args:
+        context: Optional context name for multi-cluster support
+
+    Returns:
+        kubernetes.client.CoordinationV1Api: Configured Coordination client
+
+    Raises:
+        RuntimeError: If Kubernetes config cannot be loaded
+    """
+    from kubernetes import client
+
+    try:
+        api_client = _load_config_for_context(context)
+        return client.CoordinationV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
+
+
+def get_events_client(context: str = ""):
+    """Get a configured Kubernetes Events API client.
+
+    Args:
+        context: Optional context name for multi-cluster support
+
+    Returns:
+        kubernetes.client.EventsV1Api: Configured Events client
+
+    Raises:
+        RuntimeError: If Kubernetes config cannot be loaded
+    """
+    from kubernetes import client
+
+    try:
+        api_client = _load_config_for_context(context)
+        return client.EventsV1Api(api_client=api_client)
+    except Exception as e:
+        raise RuntimeError(f"Invalid kube-config. Context: {context or 'default'}. Error: {e}")
+
+
+# Utility functions for context management
+
+def list_contexts() -> list:
+    """
+    List all available kubeconfig contexts.
+
+    Returns:
+        List of context dictionaries with name, cluster, user, namespace
+    """
+    from kubernetes import config
+
+    try:
+        kubeconfig_path = os.environ.get('KUBECONFIG', '~/.kube/config')
+        kubeconfig_path = os.path.expanduser(kubeconfig_path)
+
+        contexts, active = config.list_kube_config_contexts(config_file=kubeconfig_path)
+
+        return [
+            {
+                "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.get("name") if active else None)
+            }
+            for ctx in contexts
+        ]
+    except Exception as e:
+        logger.error(f"Error listing contexts: {e}")
+        return []
+
+
+def get_active_context() -> Optional[str]:
+    """
+    Get the current active context name.
+
+    Returns:
+        Active context name or None
+    """
+    from kubernetes import config
+
+    try:
+        kubeconfig_path = os.environ.get('KUBECONFIG', '~/.kube/config')
+        kubeconfig_path = os.path.expanduser(kubeconfig_path)
+
+        _, active = config.list_kube_config_contexts(config_file=kubeconfig_path)
+        return active.get("name") if active else None
+    except Exception as e:
+        logger.error(f"Error getting active context: {e}")
+        return None
+
+
+def context_exists(context: str) -> bool:
+    """
+    Check if a context exists in kubeconfig.
+
+    Args:
+        context: Context name to check
+
+    Returns:
+        True if context exists
+    """
+    contexts = list_contexts()
+    return any(ctx["name"] == context for ctx in contexts)
+
+
+def _get_kubectl_context_args(context: str = "") -> list:
+    """
+    Get kubectl command arguments for specifying a context.
+
+    This utility function returns the appropriate --context flag arguments
+    for kubectl commands when targeting a specific cluster.
+
+    Args:
+        context: Context name (empty string for default context)
+
+    Returns:
+        List of command arguments, e.g., ["--context", "my-cluster"]
+        or empty list if no context specified
+    """
+    if context and context.strip():
+        return ["--context", context.strip()]
+    return []

kubectl_mcp_tool/mcp_server.py

@@ -45,6 +45,16 @@ from kubectl_mcp_tool.tools import (
     is_browser_available,
     register_ui_tools,
     is_ui_available,
+    register_gitops_tools,
+    register_certs_tools,
+    register_policy_tools,
+    register_backup_tools,
+    register_keda_tools,
+    register_cilium_tools,
+    register_rollouts_tools,
+    register_capi_tools,
+    register_kubevirt_tools,
+    register_istio_tools,
 )
 from kubectl_mcp_tool.resources import register_resources
 from kubectl_mcp_tool.prompts import register_prompts
@@ -196,6 +206,23 @@ class MCPServer:
         else:
             logger.debug("MCP-UI tools disabled (install mcp-ui-server to enable)")
 
+        # Register ecosystem tools (GitOps, Cert-Manager, Policy, Backup)
+        # These tools auto-detect installed CRDs and gracefully handle missing components
+        register_gitops_tools(self.server, self.non_destructive)
+        register_certs_tools(self.server, self.non_destructive)
+        register_policy_tools(self.server, self.non_destructive)
+        register_backup_tools(self.server, self.non_destructive)
+        logger.debug("Ecosystem tools registered (GitOps, Certs, Policy, Backup)")
+
+        # Register advanced ecosystem tools (KEDA, Cilium, Rollouts, CAPI, KubeVirt, Istio)
+        register_keda_tools(self.server, self.non_destructive)
+        register_cilium_tools(self.server, self.non_destructive)
+        register_rollouts_tools(self.server, self.non_destructive)
+        register_capi_tools(self.server, self.non_destructive)
+        register_kubevirt_tools(self.server, self.non_destructive)
+        register_istio_tools(self.server, self.non_destructive)
+        logger.debug("Advanced ecosystem tools registered (KEDA, Cilium, Rollouts, CAPI, KubeVirt, Istio)")
+
     def setup_resources(self):
         """Set up MCP resources for Kubernetes data exposure."""
         register_resources(self.server)

kubectl_mcp_tool/tools/__init__.py

@@ -11,6 +11,16 @@ from .diagnostics import register_diagnostics_tools
 from .cost import register_cost_tools
 from .browser import register_browser_tools, is_browser_available
 from .ui import register_ui_tools, is_ui_available
+from .gitops import register_gitops_tools
+from .certs import register_certs_tools
+from .policy import register_policy_tools
+from .backup import register_backup_tools
+from .keda import register_keda_tools
+from .cilium import register_cilium_tools
+from .rollouts import register_rollouts_tools
+from .capi import register_capi_tools
+from .kubevirt import register_kubevirt_tools
+from .kiali import register_istio_tools
 
 __all__ = [
     "register_helm_tools",
@@ -28,4 +38,14 @@ __all__ = [
     "is_browser_available",
     "register_ui_tools",
     "is_ui_available",
+    "register_gitops_tools",
+    "register_certs_tools",
+    "register_policy_tools",
+    "register_backup_tools",
+    "register_keda_tools",
+    "register_cilium_tools",
+    "register_rollouts_tools",
+    "register_capi_tools",
+    "register_kubevirt_tools",
+    "register_istio_tools",
 ]