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

{kubectl_mcp_server-1.18.0.dist-info → kubectl_mcp_server-1.19.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kubectl-mcp-server
-Version: 1.18.0
+Version: 1.19.0
 Summary: A Model Context Protocol (MCP) server for Kubernetes with 220+ tools, 8 resources, and 8 prompts
 Home-page: https://github.com/rohitg00/kubectl-mcp-server
 Author: Rohit Ghumare
@@ -121,7 +121,6 @@ pip install kubectl-mcp-server[ui]
 - [In-Cluster Deployment](#in-cluster-deployment)
 - [Multi-Cluster Support](#multi-cluster-support)
 - [Architecture](#architecture)
-- [Agent Skills](#agent-skills-24-skills-for-ai-coding-agents)
 - [Development & Testing](#development--testing)
 - [Contributing](#contributing)
 - [Support & Community](#support--community)
@@ -876,52 +875,6 @@ kubectl_mcp_tool/
 └── cli/                    # CLI interface
 ```
 
-## Agent Skills (24 Skills for AI Coding Agents)
-
-Extend your AI coding agent with Kubernetes expertise using our [Agent Skills](https://agentskills.io) library. Skills provide specialized knowledge and workflows that agents can load on demand.
-
-### Quick Install
-
-```bash
-# Copy all skills to Claude
-cp -r kubernetes-skills/claude/* ~/.claude/skills/
-
-# Or install specific skills
-cp -r kubernetes-skills/claude/k8s-helm ~/.claude/skills/
-```
-
-### Available Skills (24)
-
-| Category | Skills |
-|----------|--------|
-| **Core Resources** | k8s-core, k8s-networking, k8s-storage |
-| **Workloads** | k8s-deploy, k8s-operations, k8s-helm |
-| **Observability** | k8s-diagnostics, k8s-troubleshoot, k8s-incident |
-| **Security** | k8s-security, k8s-policy, k8s-certs |
-| **GitOps** | k8s-gitops, k8s-rollouts |
-| **Scaling** | k8s-autoscaling, k8s-cost, k8s-backup |
-| **Multi-Cluster** | k8s-multicluster, k8s-capi, k8s-kubevirt |
-| **Networking** | k8s-service-mesh, k8s-cilium |
-| **Tools** | k8s-browser, k8s-cli |
-
-### Convert to Other Agents
-
-Use [SkillKit](https://github.com/rohitg00/skillkit) to convert skills to your preferred AI agent format:
-
-```bash
-npm install -g skillkit
-
-# Convert to Cursor format
-skillkit translate kubernetes-skills/claude --to cursor --output .cursor/rules/
-
-# Convert to Codex format
-skillkit translate kubernetes-skills/claude --to codex --output ./
-```
-
-**Supported agents:** Claude, Cursor, Codex, Gemini CLI, GitHub Copilot, Goose, Windsurf, Roo, Amp, and more.
-
-See [kubernetes-skills/README.md](kubernetes-skills/README.md) for full documentation.
-
 ## Multi-Cluster Support
 
 Seamlessly manage multiple Kubernetes clusters through natural language. **Every tool** supports an optional `context` parameter to target any cluster without switching contexts.

{kubectl_mcp_server-1.18.0.dist-info → kubectl_mcp_server-1.19.0.dist-info}/RECORD

@@ -1,11 +1,10 @@
-kubectl_mcp_server-1.18.0.dist-info/licenses/LICENSE,sha256=nH9Z0W0WNH2oQ4cPrBAU8ldDcHfeI6NUbkSGiazYWgQ,1070
-kubectl_mcp_tool/__init__.py,sha256=g48PDr6VxtD_gw-Zy4LaSkBEGvo3LOYfGTZVS28OsGo,580
+kubectl_mcp_server-1.19.0.dist-info/licenses/LICENSE,sha256=nH9Z0W0WNH2oQ4cPrBAU8ldDcHfeI6NUbkSGiazYWgQ,1070
+kubectl_mcp_tool/__init__.py,sha256=e_8lin1zD6cAw_MY-Uvgql-zjjoKlcF9zuO6kzCPbaU,580
 kubectl_mcp_tool/__main__.py,sha256=CE6cTD6PA71Ap0i5_gE17Pb9FcedOJmtGRNzZ5-TFSc,1490
 kubectl_mcp_tool/crd_detector.py,sha256=xLZSyg3iIe_MjSMI3mESe2VK8wGJzu40rJ7F72fULBs,7139
 kubectl_mcp_tool/diagnostics.py,sha256=uwolSoHadRkB-J8PAsabbexfj6sTNCIIRRrABBRXoTU,11776
-kubectl_mcp_tool/k8s_config.py,sha256=OqqYKuuxv0pQ8wtAFwqn1nyL5A2_BqmmUOOoEgoT_VE,19663
+kubectl_mcp_tool/k8s_config.py,sha256=tjP_VONsoqhd5qn0LPB25aKhiPw2qCYhJ_B52NbRYDo,15746
 kubectl_mcp_tool/mcp_server.py,sha256=-p-r-NRaX6UiHUebvO4OIozRlA2PX851rmAlW_rO3Tk,31112
-kubectl_mcp_tool/providers.py,sha256=_LMpVbCWgFrsRO_u4krSw7wFNYapzp29WtiEh-sbBeY,11521
 kubectl_mcp_tool/safety.py,sha256=7bx7tUH_hT4Y_eTnpH5knnHTsvnIZvI_0oo9MSBe_z8,5036
 kubectl_mcp_tool/auth/__init__.py,sha256=ot8ivZZkDtV8Rg0y1UYruwobKCPyxX1svqh35wWxKvY,347
 kubectl_mcp_tool/auth/config.py,sha256=wi3wuJNMyDqMeluDHL0MaJyedIFv5CFVxiUaEVaTvzk,2267
@@ -69,8 +68,8 @@ tests/test_resources.py,sha256=Z0Ex8WdRz-B3VZa1s0eAaDDGbhy7dRdqy1uFVOe2Qbo,12689
 tests/test_safety.py,sha256=5IOBQbcH2r8tANQD7ymsR6pBc6O50IspcFsuwrnwh1M,8292
 tests/test_server.py,sha256=lLvgbqutnivSgQMNrki0O48whBQt0UXjdwT047nf0nw,14415
 tests/test_tools.py,sha256=g3moVSpiFgqC107M4tBAQ6xU600rlYMPhnknyYhnTIc,34792
-kubectl_mcp_server-1.18.0.dist-info/METADATA,sha256=MGVl2vV_oVsIs6ZpwWJMpmNPUEXK-8HVS188XkNRcwI,39767
-kubectl_mcp_server-1.18.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-kubectl_mcp_server-1.18.0.dist-info/entry_points.txt,sha256=zeOxQGaNC4r58deEmqsLCU5hfMjF0VqFUt9P5wWsKEM,109
-kubectl_mcp_server-1.18.0.dist-info/top_level.txt,sha256=o5IpfOGG-lqU8rVWJeK9aYC0r4f6qEX09QiBhZlYbkQ,23
-kubectl_mcp_server-1.18.0.dist-info/RECORD,,
+kubectl_mcp_server-1.19.0.dist-info/METADATA,sha256=Ly4r-eDtkBYbDXixx9wSONKOt2S00GhAWwoCwp4KUgE,38116
+kubectl_mcp_server-1.19.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+kubectl_mcp_server-1.19.0.dist-info/entry_points.txt,sha256=zeOxQGaNC4r58deEmqsLCU5hfMjF0VqFUt9P5wWsKEM,109
+kubectl_mcp_server-1.19.0.dist-info/top_level.txt,sha256=o5IpfOGG-lqU8rVWJeK9aYC0r4f6qEX09QiBhZlYbkQ,23
+kubectl_mcp_server-1.19.0.dist-info/RECORD,,

kubectl_mcp_tool/__init__.py

@@ -7,7 +7,7 @@ with Kubernetes clusters through natural language commands.
 For more information, see: https://github.com/rohitg00/kubectl-mcp-server
 """
 
-__version__ = "1.18.0"
+__version__ = "1.19.0"
 
 from .mcp_server import MCPServer
 from .diagnostics import run_diagnostics, check_kubectl_installation, check_cluster_connection

kubectl_mcp_tool/k8s_config.py

@@ -6,39 +6,14 @@ Supports multi-cluster operations with context targeting.
 
 This module provides context-aware client creation for multi-cluster support.
 All get_*_client() functions accept an optional 'context' parameter.
-
-Environment Variables:
-    MCP_K8S_PROVIDER: Provider type (kubeconfig, in-cluster, single)
-    MCP_K8S_KUBECONFIG: Path to kubeconfig file
-    MCP_K8S_CONTEXT: Default context for single provider
-    MCP_K8S_QPS: API rate limit (default: 100)
-    MCP_K8S_BURST: API burst limit (default: 200)
-    MCP_K8S_TIMEOUT: Request timeout in seconds (default: 30)
 """
 
 import os
 import logging
-from typing import Optional, Any, List, Dict
+from typing import Optional, Any
 
 logger = logging.getLogger("mcp-server")
 
-# Try to import provider module for enhanced features
-try:
-    from .providers import (
-        KubernetesProvider,
-        ProviderConfig,
-        ProviderType,
-        UnknownContextError,
-        get_provider,
-        get_context_names,
-        get_current_context as provider_get_current_context,
-        validate_context,
-    )
-    _HAS_PROVIDER = True
-except ImportError:
-    _HAS_PROVIDER = False
-    logger.debug("Provider module not available, using basic config")
-
 _config_loaded = False
 _original_load_kube_config = None
 
@@ -139,29 +114,12 @@ def _load_config_for_context(context: str = "") -> Any:
     """
     Load kubernetes config for a specific context and return ApiClient.
 
-    Uses the provider module for caching when available.
-
     Args:
         context: Context name (empty for default)
 
     Returns:
         kubernetes.client.ApiClient configured for the context
-
-    Raises:
-        UnknownContextError: If context is not found (when provider available)
-        RuntimeError: If config cannot be loaded
     """
-    # Use provider module if available (provides caching and validation)
-    if _HAS_PROVIDER:
-        try:
-            provider = get_provider()
-            return provider.get_api_client(context)
-        except UnknownContextError:
-            raise
-        except Exception as e:
-            logger.warning(f"Provider failed, falling back to basic config: {e}")
-
-    # Fallback to basic config loading
     from kubernetes import client, config
     from kubernetes.config.config_exception import ConfigException
 
@@ -496,25 +454,6 @@ def list_contexts() -> list:
     Returns:
         List of context dictionaries with name, cluster, user, namespace
     """
-    # Use provider if available
-    if _HAS_PROVIDER:
-        try:
-            provider = get_provider()
-            contexts = provider.list_contexts()
-            return [
-                {
-                    "name": ctx.name,
-                    "cluster": ctx.cluster,
-                    "user": ctx.user,
-                    "namespace": ctx.namespace,
-                    "active": ctx.is_active
-                }
-                for ctx in contexts
-            ]
-        except Exception as e:
-            logger.warning(f"Provider list_contexts failed: {e}")
-
-    # Fallback to direct kubeconfig reading
     from kubernetes import config
 
     try:
@@ -545,14 +484,6 @@ def get_active_context() -> Optional[str]:
     Returns:
         Active context name or None
     """
-    # Use provider if available
-    if _HAS_PROVIDER:
-        try:
-            return provider_get_current_context()
-        except Exception as e:
-            logger.warning(f"Provider get_current_context failed: {e}")
-
-    # Fallback to direct kubeconfig reading
     from kubernetes import config
 
     try:
@@ -597,60 +528,3 @@ def _get_kubectl_context_args(context: str = "") -> list:
     if context and context.strip():
         return ["--context", context.strip()]
     return []
-
-
-# Re-export provider types for convenience
-if _HAS_PROVIDER:
-    __all__ = [
-        # Client functions
-        "get_k8s_client",
-        "get_apps_client",
-        "get_rbac_client",
-        "get_networking_client",
-        "get_storage_client",
-        "get_batch_client",
-        "get_autoscaling_client",
-        "get_policy_client",
-        "get_custom_objects_client",
-        "get_version_client",
-        "get_admissionregistration_client",
-        "get_apiextensions_client",
-        "get_coordination_client",
-        "get_events_client",
-        # Config functions
-        "load_kubernetes_config",
-        "patch_kubernetes_config",
-        # Context functions
-        "list_contexts",
-        "get_active_context",
-        "context_exists",
-        # Provider types (when available)
-        "KubernetesProvider",
-        "ProviderConfig",
-        "ProviderType",
-        "UnknownContextError",
-        "get_provider",
-        "validate_context",
-    ]
-else:
-    __all__ = [
-        "get_k8s_client",
-        "get_apps_client",
-        "get_rbac_client",
-        "get_networking_client",
-        "get_storage_client",
-        "get_batch_client",
-        "get_autoscaling_client",
-        "get_policy_client",
-        "get_custom_objects_client",
-        "get_version_client",
-        "get_admissionregistration_client",
-        "get_apiextensions_client",
-        "get_coordination_client",
-        "get_events_client",
-        "load_kubernetes_config",
-        "patch_kubernetes_config",
-        "list_contexts",
-        "get_active_context",
-        "context_exists",
-    ]

kubectl_mcp_tool/providers.py

@@ -1,347 +0,0 @@
-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)