kubectl-mcp-server 1.22.0__tar.gz → 1.23.1__tar.gz

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kubectl-mcp-server
-Version: 1.22.0
+Version: 1.23.1
 Summary: A Model Context Protocol (MCP) server for Kubernetes with 270+ tools, 8 resources, and 8 prompts
 Home-page: https://github.com/rohitg00/kubectl-mcp-server
 Author: Rohit Ghumare

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kubectl-mcp-server
-Version: 1.22.0
+Version: 1.23.1
 Summary: A Model Context Protocol (MCP) server for Kubernetes with 270+ tools, 8 resources, and 8 prompts
 Home-page: https://github.com/rohitg00/kubectl-mcp-server
 Author: Rohit Ghumare

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_server.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ kubectl_mcp_tool/prompts/prompts.py
 kubectl_mcp_tool/resources/__init__.py
 kubectl_mcp_tool/resources/resources.py
 kubectl_mcp_tool/tools/__init__.py
+kubectl_mcp_tool/tools/_cli_utils.py
 kubectl_mcp_tool/tools/backup.py
 kubectl_mcp_tool/tools/browser.py
 kubectl_mcp_tool/tools/capi.py

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/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.22.0"
+__version__ = "1.23.1"
 
 from .mcp_server import MCPServer
 from .diagnostics import run_diagnostics, check_kubectl_installation, check_cluster_connection

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/k8s_config.py

@@ -203,6 +203,7 @@ try:
         KubernetesProvider,
         ProviderConfig,
         ProviderType,
+        ProviderError,
         UnknownContextError,
         get_provider,
         get_context_names,
@@ -262,9 +263,21 @@ def load_kubernetes_config(context: str = ""):
 
 
 def _patched_load_kube_config(*args, **kwargs):
-    """Patched version of load_kube_config that tries in-cluster first."""
+    """Patched version of load_kube_config that tries in-cluster first.
+
+    When called with explicit arguments (config_file, context, client_configuration),
+    always pass through to the original function. Only try in-cluster as a
+    fallback for bare calls during initial module loading.
+    """
     global _config_loaded, _original_load_kube_config
 
+    has_explicit_args = bool(args) or bool(kwargs)
+
+    if has_explicit_args and _original_load_kube_config:
+        _original_load_kube_config(*args, **kwargs)
+        _config_loaded = True
+        return
+
     if _config_loaded:
         return
 
@@ -326,7 +339,7 @@ def _load_config_for_context(context: str = "") -> Any:
         try:
             provider = get_provider()
             return provider.get_api_client(context)
-        except UnknownContextError:
+        except (UnknownContextError, ProviderError):
             raise
         except Exception as e:
             logger.warning(f"Provider failed, falling back to basic config: {e}")
@@ -338,11 +351,20 @@ def _load_config_for_context(context: str = "") -> Any:
         config.load_incluster_config()
         return client.ApiClient()
     except ConfigException:
-        pass
+        logger.debug("In-cluster config not available in fallback path")
 
     kubeconfig_path = os.environ.get('KUBECONFIG', '~/.kube/config')
     kubeconfig_path = os.path.expanduser(kubeconfig_path)
 
+    if not os.path.exists(kubeconfig_path):
+        raise RuntimeError(
+            f"No Kubernetes configuration found. "
+            f"In-cluster config not available and kubeconfig not found at '{kubeconfig_path}'. "
+            f"If running in a Kubernetes pod, ensure the ServiceAccount token is mounted "
+            f"and KUBERNETES_SERVICE_HOST/KUBERNETES_SERVICE_PORT env vars are set. "
+            f"Set MCP_K8S_PROVIDER=in-cluster for in-cluster deployments."
+        )
+
     api_config = client.Configuration()
 
     if context:
@@ -543,7 +565,8 @@ _BASE_EXPORTS = [
 if _HAS_PROVIDER:
     __all__ = _BASE_EXPORTS + [
         "KubernetesProvider", "ProviderConfig", "ProviderType",
-        "UnknownContextError", "get_provider", "validate_context",
+        "ProviderError", "UnknownContextError",
+        "get_provider", "validate_context",
     ]
 else:
     __all__ = _BASE_EXPORTS

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/mcp_server.py

@@ -23,15 +23,10 @@ import logging
 import asyncio
 import os
 import platform
-import signal
-from pathlib import Path
 from typing import List, Optional, Any, Dict
 
-# Import k8s_config early to patch kubernetes config for in-cluster support
-# This must be done before any tools are imported
 import kubectl_mcp_tool.k8s_config  # noqa: F401
 
-# Import safety mode for operation control
 from kubectl_mcp_tool.safety import (
     SafetyMode,
     set_safety_mode,
@@ -39,7 +34,6 @@ from kubectl_mcp_tool.safety import (
     get_mode_info,
 )
 
-# Import observability for metrics and tracing
 from kubectl_mcp_tool.observability import (
     get_stats_collector,
     get_metrics,
@@ -52,7 +46,6 @@ from kubectl_mcp_tool.observability import (
     record_tool_error_metric,
 )
 
-# Import config loader
 from kubectl_mcp_tool.config import (
     load_config,
     get_config,
@@ -60,12 +53,13 @@ from kubectl_mcp_tool.config import (
     setup_sighup_handler,
 )
 
-# Import custom prompts
 from kubectl_mcp_tool.prompts import (
     load_prompts_from_config,
     get_builtin_prompts,
 )
 
+from kubectl_mcp_tool import __version__
+
 from kubectl_mcp_tool.tools import (
     register_helm_tools,
     register_pod_tools,
@@ -134,23 +128,13 @@ for handler in logging.root.handlers[:]:
     if isinstance(handler, logging.StreamHandler) and handler.stream == sys.stdout:
         logging.root.removeHandler(handler)
 
-# FastMCP 3 from gofastmcp.com (standalone package)
-# To revert to official SDK: from mcp.server.fastmcp import FastMCP
 try:
     from fastmcp import FastMCP
-except ImportError:
-    logger.error("FastMCP not found. Installing...")
-    import subprocess
-    try:
-        subprocess.check_call(
-            [sys.executable, "-m", "pip", "install", "fastmcp>=3.0.0b1"],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL
-        )
-        from fastmcp import FastMCP
-    except Exception as e:
-        logger.error(f"Failed to install FastMCP: {e}")
-        raise
+except ImportError as err:
+    raise ImportError(
+        "FastMCP is required but not installed. "
+        "Install with: pip install 'fastmcp>=3.0.0b1'"
+    ) from err
 
 
 class MCPServer:
@@ -622,7 +606,7 @@ class MCPServer:
                         },
                         "serverInfo": {
                             "name": self.name,
-                            "version": "1.2.0"
+                            "version": __version__
                         }
                     }
                 elif method == "tools/list":

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/providers.py

@@ -3,7 +3,6 @@ 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")
 
@@ -150,8 +149,37 @@ class KubernetesProvider:
             raise ProviderError(f"Failed to load context '{self.config.context}': {e}")
 
     def _initialize_kubeconfig(self):
-        """Initialize for multi-cluster kubeconfig provider."""
+        """Initialize for multi-cluster kubeconfig provider.
+
+        Falls back to in-cluster config if kubeconfig file is not found.
+        """
         from kubernetes import config
+        from kubernetes.config.config_exception import ConfigException
+
+        kubeconfig_exists = os.path.exists(self.config.kubeconfig_path)
+
+        if not kubeconfig_exists:
+            try:
+                config.load_incluster_config()
+                self._in_cluster = True
+                self._active_context = "in-cluster"
+                self._contexts_cache = []
+                logger.info(
+                    f"Kubeconfig not found at {self.config.kubeconfig_path}, "
+                    f"using in-cluster config"
+                )
+                return
+            except ConfigException:
+                raise ProviderError(
+                    f"No Kubernetes configuration found. "
+                    f"Kubeconfig not found at '{self.config.kubeconfig_path}' and "
+                    f"in-cluster config is not available. "
+                    f"Ensure a valid kubeconfig exists, or if running inside a "
+                    f"Kubernetes pod, verify the ServiceAccount token is mounted "
+                    f"and KUBERNETES_SERVICE_HOST/KUBERNETES_SERVICE_PORT env vars "
+                    f"are set. For in-cluster deployments, set "
+                    f"MCP_K8S_PROVIDER=in-cluster."
+                )
 
         try:
             contexts, active = config.list_kube_config_contexts(

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/safety.py

@@ -5,8 +5,7 @@ Provides read-only and disable-destructive modes to prevent accidental cluster m
 """
 
 from enum import Enum
-from functools import wraps
-from typing import Any, Callable, Dict, Set
+from typing import Any, Dict, Set
 import logging
 
 logger = logging.getLogger("mcp-server")
@@ -86,57 +85,6 @@ def set_safety_mode(mode: SafetyMode) -> None:
     logger.info(f"Safety mode set to: {mode.value}")
 
 
-def is_operation_allowed(operation_name: str) -> tuple[bool, str]:
-    """
-    Check if an operation is allowed under the current safety mode.
-
-    Returns:
-        Tuple of (allowed: bool, reason: str)
-    """
-    mode = get_safety_mode()
-
-    if mode == SafetyMode.NORMAL:
-        return True, ""
-
-    if mode == SafetyMode.READ_ONLY:
-        if operation_name in WRITE_OPERATIONS or operation_name in DESTRUCTIVE_OPERATIONS:
-            return False, f"Operation '{operation_name}' blocked: read-only mode is enabled"
-
-    if mode == SafetyMode.DISABLE_DESTRUCTIVE:
-        if operation_name in DESTRUCTIVE_OPERATIONS:
-            return False, f"Operation '{operation_name}' blocked: destructive operations are disabled"
-
-    return True, ""
-
-
-def check_safety_mode(func: Callable) -> Callable:
-    """
-    Decorator to check safety mode before executing a tool function.
-
-    Usage:
-        @check_safety_mode
-        def delete_pod(...):
-            ...
-    """
-    @wraps(func)
-    def wrapper(*args, **kwargs) -> Dict[str, Any]:
-        operation_name = func.__name__
-        allowed, reason = is_operation_allowed(operation_name)
-
-        if not allowed:
-            logger.warning(f"Blocked operation: {operation_name} (mode: {get_safety_mode().value})")
-            return {
-                "success": False,
-                "error": reason,
-                "blocked_by": get_safety_mode().value,
-                "operation": operation_name
-            }
-
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
 def get_mode_info() -> Dict[str, Any]:
     """Get information about the current safety mode."""
     mode = get_safety_mode()

kubectl_mcp_server-1.23.1/kubectl_mcp_tool/tools/_cli_utils.py

@@ -0,0 +1,75 @@
+import subprocess
+from functools import lru_cache
+from typing import Any, Dict, List, Optional
+
+
+@lru_cache(maxsize=16)
+def cli_available(binary: str) -> bool:
+    """Check if a CLI binary is available (cached)."""
+    try:
+        result = subprocess.run(
+            [binary, "version"],
+            capture_output=True,
+            timeout=10
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+@lru_cache(maxsize=16)
+def get_cli_version(binary: str) -> Optional[str]:
+    """Get CLI binary version string (cached)."""
+    try:
+        result = subprocess.run(
+            [binary, "version"],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return None
+    except Exception:
+        return None
+
+
+def run_cli(
+    binary: str,
+    args: List[str],
+    timeout: int = 300,
+    capture_output: bool = True
+) -> Dict[str, Any]:
+    """Run a CLI command and return a standardized result dict.
+
+    Args:
+        binary: CLI binary name (e.g., "kind", "vcluster", "helm")
+        args: Command arguments (without the binary prefix)
+        timeout: Command timeout in seconds
+        capture_output: Whether to capture stdout/stderr
+
+    Returns:
+        Dict with success status and output/error
+    """
+    cmd = [binary, *args]
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=capture_output,
+            text=True,
+            timeout=timeout
+        )
+        if result.returncode == 0:
+            output = result.stdout.strip() if capture_output else ""
+            return {"success": True, "output": output}
+        return {
+            "success": False,
+            "error": result.stderr.strip() if capture_output else f"Command failed with exit code {result.returncode}"
+        }
+    except subprocess.TimeoutExpired:
+        return {"success": False, "error": f"Command timed out after {timeout} seconds"}
+    except FileNotFoundError:
+        return {"success": False, "error": f"{binary} CLI not available"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/tools/cluster.py

@@ -23,18 +23,12 @@ from kubectl_mcp_tool.k8s_config import (
     disable_kubeconfig_watch,
     is_stateless_mode,
     set_stateless_mode,
+    _get_kubectl_context_args,
 )
 
 logger = logging.getLogger("mcp-server")
 
 
-def _get_kubectl_context_args(context: str = "") -> List[str]:
-    """Get kubectl context arguments."""
-    if context:
-        return ["--context", context]
-    return []
-
-
 # DNS-1123 subdomain regex for node name validation
 _DNS_1123_PATTERN = re.compile(r'^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$')
 
@@ -60,7 +54,7 @@ def _validate_node_name(name: str) -> tuple:
     return True, None
 
 
-def register_cluster_tools(server, non_destructive: bool):
+def register_cluster_tools(server: "FastMCP", non_destructive: bool):
     """Register cluster and context management tools."""
 
     @server.tool(

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/tools/core.py

@@ -7,19 +7,13 @@ from mcp.types import ToolAnnotations
 from ..k8s_config import (
     get_k8s_client,
     get_apiextensions_client,
+    _get_kubectl_context_args,
 )
 
 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_core_tools(server, non_destructive: bool):
+def register_core_tools(server: "FastMCP", non_destructive: bool):
     """Register core Kubernetes resource tools."""
 
     @server.tool(

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/tools/cost.py

@@ -6,18 +6,11 @@ from typing import Any, Dict, List, Optional
 
 from mcp.types import ToolAnnotations
 
-from ..k8s_config import get_k8s_client, get_apps_client
+from ..k8s_config import get_k8s_client, get_apps_client, _get_kubectl_context_args
 
 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 _parse_cpu(cpu_str: str) -> int:
     """Parse CPU string to millicores."""
     try:
@@ -28,7 +21,7 @@ def _parse_cpu(cpu_str: str) -> int:
             return int(cpu_str[:-1]) // 1000000
         else:
             return int(float(cpu_str) * 1000)
-    except:
+    except (ValueError, TypeError):
         return 0
 
 
@@ -50,7 +43,7 @@ def _parse_memory(mem_str: str) -> int:
             return int(mem_str[:-1]) * 1000000000
         else:
             return int(mem_str)
-    except:
+    except (ValueError, TypeError):
         return 0
 
 
@@ -61,11 +54,11 @@ def _calculate_available(hard: str, used: str) -> str:
         used_num = int(re.sub(r'[^\d]', '', str(used)) or 0)
         suffix = re.sub(r'[\d]', '', str(hard))
         return f"{max(0, hard_num - used_num)}{suffix}"
-    except:
+    except (ValueError, TypeError):
         return "N/A"
 
 
-def register_cost_tools(server, non_destructive: bool):
+def register_cost_tools(server: "FastMCP", non_destructive: bool):
     """Register cost and resource optimization tools."""
 
     @server.tool(

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/tools/deployments.py

@@ -10,19 +10,13 @@ from ..k8s_config import (
     get_autoscaling_client,
     get_policy_client,
     _load_config_for_context,
+    _get_kubectl_context_args,
 )
 
 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_deployment_tools(server, non_destructive: bool):
+def register_deployment_tools(server: "FastMCP", non_destructive: bool):
     """Register deployment and workload management tools."""
 
     @server.tool(

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/tools/diagnostics.py

@@ -4,19 +4,12 @@ from typing import Any, Dict, List, Optional
 
 from mcp.types import ToolAnnotations
 
-from ..k8s_config import get_k8s_client, get_apps_client
+from ..k8s_config import get_k8s_client, get_apps_client, _get_kubectl_context_args
 
 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_diagnostics_tools(server, non_destructive: bool):
+def register_diagnostics_tools(server: "FastMCP", non_destructive: bool):
     """Register diagnostic and troubleshooting tools.
 
     Note: Pod-specific diagnostic tools (diagnose_pod_crash, detect_pending_pods,

{kubectl_mcp_server-1.22.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/tools/helm.py

@@ -8,6 +8,8 @@ from typing import Any, Callable, Dict, List, Optional
 import yaml
 from mcp.types import ToolAnnotations
 
+from kubectl_mcp_tool.k8s_config import _get_kubectl_context_args
+
 logger = logging.getLogger("mcp-server")
 
 
@@ -18,15 +20,43 @@ def _get_helm_context_args(context: str) -> List[str]:
     return []
 
 
-def _get_kubectl_context_args(context: str) -> List[str]:
-    """Get kubectl context arguments if context is specified."""
-    if context:
-        return ["--context", context]
-    return []
+def _add_helm_repo(repo: str, chart: str) -> tuple:
+    """Add a Helm repo and return the updated chart reference.
+
+    Args:
+        repo: Repository in format 'repo_name=repo_url'
+        chart: Original chart reference
+
+    Returns:
+        Tuple of (success: bool, chart_or_error: str)
+    """
+    repo_parts = repo.split("=", 1)
+    if len(repo_parts) != 2:
+        return False, "Repository format should be 'repo_name=repo_url'"
+
+    repo_name, repo_url = (p.strip() for p in repo_parts)
+    if not repo_name or not repo_url:
+        return False, "Repository format should be 'repo_name=repo_url'"
+    try:
+        subprocess.check_output(
+            ["helm", "repo", "add", repo_name, repo_url],
+            stderr=subprocess.PIPE, text=True
+        )
+        subprocess.check_output(
+            ["helm", "repo", "update"],
+            stderr=subprocess.PIPE, text=True
+        )
+    except subprocess.CalledProcessError as e:
+        error_msg = e.stderr if hasattr(e, 'stderr') else str(e)
+        return False, f"Failed to add Helm repo: {error_msg}"
+
+    if '/' not in chart:
+        chart = f"{repo_name}/{chart}"
+    return True, chart
 
 
 def register_helm_tools(
-    server,
+    server: "FastMCP",
     non_destructive: bool,
     check_helm_fn: Callable[[], bool]
 ):
@@ -69,25 +99,10 @@ def register_helm_tools(
 
         try:
             if repo:
-                try:
-                    repo_parts = repo.split('=')
-                    if len(repo_parts) != 2:
-                        return {"success": False, "error": "Repository format should be 'repo_name=repo_url'"}
-
-                    repo_name, repo_url = repo_parts
-                    repo_add_cmd = ["helm", "repo", "add", repo_name, repo_url]
-                    logger.debug(f"Running command: {' '.join(repo_add_cmd)}")
-                    subprocess.check_output(repo_add_cmd, stderr=subprocess.PIPE, text=True)
-
-                    repo_update_cmd = ["helm", "repo", "update"]
-                    logger.debug(f"Running command: {' '.join(repo_update_cmd)}")
-                    subprocess.check_output(repo_update_cmd, stderr=subprocess.PIPE, text=True)
-
-                    if '/' not in chart:
-                        chart = f"{repo_name}/{chart}"
-                except subprocess.CalledProcessError as e:
-                    logger.error(f"Error adding Helm repo: {e.stderr if hasattr(e, 'stderr') else str(e)}")
-                    return {"success": False, "error": f"Failed to add Helm repo: {e.stderr if hasattr(e, 'stderr') else str(e)}"}
+                success, result = _add_helm_repo(repo, chart)
+                if not success:
+                    return {"success": False, "error": result}
+                chart = result
 
             cmd = ["helm"] + _get_helm_context_args(context) + ["install", name, chart, "-n", namespace]
 
@@ -162,25 +177,10 @@ def register_helm_tools(
 
         try:
             if repo:
-                try:
-                    repo_parts = repo.split('=')
-                    if len(repo_parts) != 2:
-                        return {"success": False, "error": "Repository format should be 'repo_name=repo_url'"}
-
-                    repo_name, repo_url = repo_parts
-                    repo_add_cmd = ["helm", "repo", "add", repo_name, repo_url]
-                    logger.debug(f"Running command: {' '.join(repo_add_cmd)}")
-                    subprocess.check_output(repo_add_cmd, stderr=subprocess.PIPE, text=True)
-
-                    repo_update_cmd = ["helm", "repo", "update"]
-                    logger.debug(f"Running command: {' '.join(repo_update_cmd)}")
-                    subprocess.check_output(repo_update_cmd, stderr=subprocess.PIPE, text=True)
-
-                    if '/' not in chart:
-                        chart = f"{repo_name}/{chart}"
-                except subprocess.CalledProcessError as e:
-                    logger.error(f"Error adding Helm repo: {e.stderr if hasattr(e, 'stderr') else str(e)}")
-                    return {"success": False, "error": f"Failed to add Helm repo: {e.stderr if hasattr(e, 'stderr') else str(e)}"}
+                success, result = _add_helm_repo(repo, chart)
+                if not success:
+                    return {"success": False, "error": result}
+                chart = result
 
             cmd = ["helm"] + _get_helm_context_args(context) + ["upgrade", name, chart, "-n", namespace]