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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rf-mcp
-Version: 0.34.0.dev1
+Version: 0.34.0.dev3
 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.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rf-mcp"
-version = "0.34.0.dev1"
+version = "0.34.0.dev3"
 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.dev3}/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.dev3}/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.dev3}/src/robotmcp/components/test_builder.py

@@ -110,6 +110,39 @@ class GeneratedTestSuite:
     column_headers: Optional[List[str]] = None
 
 
+# change: fix-suite-arg-escape-roundtrip. RF recognizes only \n \r \t (+ \xHH \uHHHH
+# \UHHHHHHHH) as escapes and drops the backslash for anything else. Preserve those and the
+# syntax escapes rf-mcp/agents rely on; double every other literal backslash so RF's parser
+# recovers the value. Idempotent: an already-doubled \\ is kept as a pair.
+_RF_ESCAPE_PRESERVE_NEXT = frozenset("nrtxuU=#$@&%{} ")
+
+
+def _escape_aware_backslashes(s: str) -> str:
+    """Double literal backslashes that RF would drop, preserving real/intended escapes."""
+    if "\\" not in s:
+        return s
+    out: List[str] = []
+    i, n = 0, len(s)
+    while i < n:
+        c = s[i]
+        if c == "\\":
+            nxt = s[i + 1] if i + 1 < n else ""
+            if nxt == "\\":
+                out.append("\\\\")      # keep an existing \\ pair verbatim (idempotent)
+                i += 2
+                continue
+            if nxt in _RF_ESCAPE_PRESERVE_NEXT:
+                out.append("\\")        # recognized/intended escape — do not double
+                i += 1
+                continue
+            out.append("\\\\")          # unrecognized escape / trailing lone \ — double it
+            i += 1
+            continue
+        out.append(c)
+        i += 1
+    return "".join(out)
+
+
 class TestBuilder:
     """Builds Robot Framework test suites from successful execution steps."""
 
@@ -4098,6 +4131,24 @@ class TestBuilder:
         # Fix malformed evaluation namespace expressions first
         arg = self._fix_malformed_evaluation_namespace(arg)
 
+        # Platform-independent path form (change: fix-suite-path-escaping): a Windows
+        # DRIVE-LETTER path is rewritten to forward slashes — valid for Start Process/
+        # subprocess and the OperatingSystem keywords on BOTH Windows and POSIX, and
+        # RF-escape-safe. Without this, RF's escape processing corrupts a literal
+        # backslash path (C:\WINDOWS -> C:WINDOWS; C:\name -> embedded newline).
+        # Only the unambiguous drive-letter shape is touched; flags (/w), URLs
+        # (https://…) and variable references do NOT match and are left unchanged.
+        if re.match(r"^[A-Za-z]:[\\/]", arg):
+            arg = arg.replace("\\", "/")
+
+        # Escape-aware backslash round-trip (change: fix-suite-arg-escape-roundtrip). RF
+        # drops the backslash for every escape it does not recognize (\d -> d, \W -> W), so
+        # a literal backslash (regex, relative Windows path) is corrupted on parse. Double
+        # a backslash ONLY where RF would drop it; PRESERVE RF's real escapes (\n \r \t,
+        # \x \u \U), an already-doubled \\, and the intended syntax escapes (\= \# \$ \{ \}
+        # \@ \& \% \<space>). Idempotent, and leaves ${..} references (no backslash) intact.
+        arg = _escape_aware_backslashes(arg)
+
         # Escape literal newlines/tabs so they don't break the .robot line structure.
         # RF uses \n / \t as escape sequences, so we emit \\n / \\t in the text
         # which RF interprets back as the literal characters at runtime.

{rf_mcp-0.34.0.dev1 → rf_mcp-0.34.0.dev3}/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()