rf-mcp 0.34.0.dev1__tar.gz → 0.34.0.dev2__tar.gz

{rf_mcp-0.34.0.dev1 → rf_mcp-0.34.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rf-mcp
-Version: 0.34.0.dev1
+Version: 0.34.0.dev2
 Summary: Robot Framework MCP Server - Natural Language Test Automation Bridge
 Project-URL: Homepage, https://github.com/manykarim/rf-mcp
 Project-URL: Repository, https://github.com/manykarim/rf-mcp

{rf_mcp-0.34.0.dev1 → rf_mcp-0.34.0.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rf-mcp"
-version = "0.34.0.dev1"
+version = "0.34.0.dev2"
 description = "Robot Framework MCP Server - Natural Language Test Automation Bridge"
 authors = [{ name = "Many Kasiriha" }]
 license = { text = "Apache-2.0" }

{rf_mcp-0.34.0.dev1 → rf_mcp-0.34.0.dev2}/src/robotmcp/components/execution/platynui_focus.py

@@ -1052,7 +1052,7 @@ def x11_window_present(
     try:
         proc = subprocess.run(
             [sys.executable, "-c", _X11_WINDOW_PROBE_SRC, *names],
-            capture_output=True, text=True, timeout=5, env=env,
+            capture_output=True, text=True, timeout=5, env=env, stdin=subprocess.DEVNULL,
         )
         out = (proc.stdout or "").strip()
         return out if out in ("present", "absent", "unknown") else "unknown"
@@ -1143,7 +1143,7 @@ def x11_display_pids() -> Optional[frozenset]:
     try:
         proc = subprocess.run(
             [sys.executable, "-c", _X11_PID_LIST_PROBE_SRC],
-            capture_output=True, text=True, timeout=5, env=dict(os.environ),
+            capture_output=True, text=True, timeout=5, env=dict(os.environ), stdin=subprocess.DEVNULL,
         )
         out = (proc.stdout or "").strip()
         if not out or out == "unknown":

{rf_mcp-0.34.0.dev1 → rf_mcp-0.34.0.dev2}/src/robotmcp/components/execution/suite_execution_service.py

@@ -13,6 +13,7 @@ import json
 import io
 import subprocess
 import sys
+import signal
 from contextlib import redirect_stdout, redirect_stderr
 
 try:
@@ -31,6 +32,37 @@ from robotmcp.models.config_models import ExecutionConfig
 logger = logging.getLogger(__name__)
 
 
+def _kill_process_tree(proc: "subprocess.Popen") -> None:
+    """Best-effort terminate a child process AND all of its descendants.
+
+    change: fix-mcp-subprocess-stdin-deadlock. A plain ``proc.kill()`` reaps only the
+    direct child; a surviving grandchild (e.g. the uv-trampoline launcher's real
+    interpreter) keeps the captured stdout/stderr pipes open and hangs the post-kill
+    ``communicate()``. On Windows we ``taskkill /F /T`` the PID tree; on POSIX we
+    ``killpg`` (the child is spawned with ``start_new_session=True``). Never raises.
+    """
+    pid = getattr(proc, "pid", None)
+    if pid is not None:
+        try:
+            if os.name == "nt":
+                subprocess.run(
+                    ["taskkill", "/F", "/T", "/PID", str(pid)],
+                    stdin=subprocess.DEVNULL,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    timeout=10,
+                )
+            else:
+                os.killpg(os.getpgid(pid), signal.SIGKILL)
+        except Exception:
+            pass  # missing taskkill / already-dead / permission — fall through
+    # Ensure the direct child is gone regardless.
+    try:
+        proc.kill()
+    except Exception:
+        pass
+
+
 class SuiteExecutionService:
     """Service for executing Robot Framework test suites in dry run and normal modes."""
     
@@ -297,6 +329,12 @@ class SuiteExecutionService:
             start_time = datetime.now()
             
             # Prepare Robot Framework options
+            # NOTE: do NOT add --console none here. The dry-run captures RF's console output
+            # via a PIPE and the validation parser reads it (there is no output.xml —
+            # --output NONE), so suppressing the console would blank suite_info/test_count.
+            # The stdin=DEVNULL isolation below (change: fix-mcp-subprocess-stdin-deadlock)
+            # is what fixes the Windows deadlock; the captured stdout is a pipe, not an
+            # inherited handle, so there is nothing to defend against with --console none.
             rf_options = ["--dryrun", "--output", "NONE", "--report", "NONE", "--log", "NONE"]
             
             # Add validation level options (execution_options may override loglevel)
@@ -325,20 +363,42 @@ class SuiteExecutionService:
             # write to the underlying stdout fd and bypass contextlib.redirect_stdout).
             def run_robot_dry():
                 cmd = [sys.executable, "-m", "robot", *rf_options]
+                # stdin=DEVNULL: the dry-run child MUST NOT inherit the MCP server's stdin
+                # (its JSON-RPC read channel). On Windows an inherited synchronous stdin
+                # pipe deadlocks the child's C-runtime stdio init behind the server's
+                # pending read → the dry-run hangs the full timeout (change:
+                # fix-mcp-subprocess-stdin-deadlock). Popen (not subprocess.run) so a
+                # timeout can reap the whole tree BEFORE draining the pipes.
+                popen_kwargs = dict(
+                    stdin=subprocess.DEVNULL,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                )
+                if os.name != "nt":
+                    popen_kwargs["start_new_session"] = True  # own group for killpg
                 try:
-                    proc = subprocess.run(
-                        cmd,
-                        capture_output=True,
-                        text=True,
-                        encoding="utf-8",
-                        errors="replace",
-                        timeout=timeout_s,
-                    )
-                    return proc.returncode, proc.stdout or "", proc.stderr or ""
+                    proc = subprocess.Popen(cmd, **popen_kwargs)
+                except Exception as e:
+                    logger.error(f"Robot Framework dry run error: {e}")
+                    return 252, "", str(e)
+                try:
+                    stdout, stderr = proc.communicate(timeout=timeout_s)
+                    return proc.returncode, stdout or "", stderr or ""
                 except subprocess.TimeoutExpired:
+                    # Reap the whole tree so an orphaned grandchild cannot keep the
+                    # capture pipes open and hang the drain below.
+                    _kill_process_tree(proc)
+                    try:
+                        proc.communicate(timeout=5)
+                    except Exception:
+                        pass
                     raise
                 except Exception as e:
                     logger.error(f"Robot Framework dry run error: {e}")
+                    _kill_process_tree(proc)
                     return 252, "", str(e)
 
             loop = asyncio.get_event_loop()

{rf_mcp-0.34.0.dev1 → rf_mcp-0.34.0.dev2}/src/robotmcp/utils/library_checker.py

@@ -97,9 +97,12 @@ class LibraryAvailabilityChecker:
     def check_pip_package_installed(self, package_name: str) -> bool:
         """Check if a pip package is installed using pip list."""
         try:
+            # stdin=DEVNULL: never inherit the MCP server's stdin — an inherited
+            # synchronous stdin pipe deadlocks this child on Windows behind the server's
+            # pending JSON-RPC read (change: fix-mcp-subprocess-stdin-deadlock).
             result = subprocess.run([
                 sys.executable, '-m', 'pip', 'list', '--format=freeze'
-            ], capture_output=True, text=True, timeout=10)
+            ], capture_output=True, text=True, timeout=10, stdin=subprocess.DEVNULL)
             
             if result.returncode == 0:
                 installed_packages = result.stdout.lower()