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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kubectl-mcp-server
-Version: 1.23.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.23.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.23.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.23.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.23.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.23.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.23.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.23.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")
 

{kubectl_mcp_server-1.23.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.23.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.23.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.23.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.23.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.23.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.23.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]
 

{kubectl_mcp_server-1.23.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/tools/kind.py

@@ -7,17 +7,13 @@ It's a tool from Kubernetes SIG for local development and CI testing.
 import subprocess
 import json
 import re
+import shlex
 import os
 import tempfile
 import yaml
 from typing import Dict, Any, List, Optional
 
-try:
-    from fastmcp import FastMCP
-    from fastmcp.tools import ToolAnnotations
-except ImportError:
-    from mcp.server.fastmcp import FastMCP
-    from mcp.types import ToolAnnotations
+from mcp.types import ToolAnnotations
 
 
 def _kind_available() -> bool:
@@ -911,7 +907,7 @@ def kind_node_exec(
         }
 
     result = _run_docker(
-        ["exec", node] + command.split(),
+        ["exec", node] + shlex.split(command),
         timeout=120
     )
 
@@ -1350,7 +1346,7 @@ def kind_provider_info() -> Dict[str, Any]:
         }
 
 
-def register_kind_tools(mcp: FastMCP, non_destructive: bool = False):
+def register_kind_tools(mcp: "FastMCP", non_destructive: bool = False):
     """Register kind (Kubernetes IN Docker) tools with the MCP server."""
 
     @mcp.tool(annotations=ToolAnnotations(readOnlyHint=True))

{kubectl_mcp_server-1.23.0 → kubectl_mcp_server-1.23.1}/kubectl_mcp_tool/tools/networking.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_networking_client
+from ..k8s_config import get_k8s_client, get_networking_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_networking_tools(server, non_destructive: bool):
+def register_networking_tools(server: "FastMCP", non_destructive: bool):
     """Register networking-related tools."""
 
     @server.tool(
@@ -271,7 +264,7 @@ def register_networking_tools(server, non_destructive: bool):
             # Get endpoints
             try:
                 endpoints = v1.read_namespaced_endpoints(service_name, namespace)
-            except:
+            except Exception:
                 endpoints = None
 
             # Get pods matching selector
@@ -354,11 +347,22 @@ def register_networking_tools(server, non_destructive: bool):
             namespace: Namespace of the pod
             context: Kubernetes context to use (uses current context if not specified)
         """
+        if non_destructive:
+            return {
+                "success": False,
+                "error": "port_forward is not allowed in non-destructive mode"
+            }
         try:
-            import os
-            ctx_args = " ".join(_get_kubectl_context_args(context))
-            cmd = f"kubectl {ctx_args} port-forward {pod_name} {local_port}:{pod_port} -n {namespace} &"
-            os.system(cmd)
+            cmd = ["kubectl"] + _get_kubectl_context_args(context) + [
+                "port-forward", pod_name,
+                f"{int(local_port)}:{int(pod_port)}",
+                "-n", namespace
+            ]
+            subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
             return {
                 "success": True,
                 "context": context or "current",