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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rf-mcp
-Version: 0.34.0.dev0
+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
@@ -33,6 +33,9 @@ Provides-Extra: api
 Requires-Dist: robotframework-requests; extra == 'api'
 Provides-Extra: database
 Requires-Dist: robotframework-databaselibrary; extra == 'database'
+Provides-Extra: desktop
+Requires-Dist: platynui-cli==0.13.0.dev2; (python_version >= '3.12') and extra == 'desktop'
+Requires-Dist: robotframework-platynui==0.13.0.dev2; (python_version >= '3.12') and extra == 'desktop'
 Provides-Extra: frontend
 Requires-Dist: django<5.0,>=4.2; extra == 'frontend'
 Requires-Dist: uvicorn[standard]>=0.24; extra == 'frontend'
@@ -221,10 +224,11 @@ uv pip install rf-mcp[web]       # Browser Library + SeleniumLibrary
 uv pip install rf-mcp[mobile]    # AppiumLibrary
 uv pip install rf-mcp[api]       # RequestsLibrary
 uv pip install rf-mcp[database]  # DatabaseLibrary
+uv pip install --pre rf-mcp[desktop]  # PlatynUI new-core (Rust) native desktop — Python 3.12+, prerelease
 uv pip install rf-mcp[frontend]  # Django-based web frontend dashboard
 uv pip install rf-mcp[memory]    # Persistent semantic memory (sqlite-vec + model2vec)
 uv pip install rf-mcp[semantic]  # Sentence-transformers for find_keywords embedding ranking
-uv pip install rf-mcp[all]       # All optional Robot Framework libraries
+uv pip install rf-mcp[all]       # All optional Robot Framework libraries (desktop is separate — prerelease/3.12+)
 
 # Alternatively, add to an existing uv project
 uv init

{rf_mcp-0.34.0.dev0 → rf_mcp-0.34.0.dev2}/README.md

@@ -167,10 +167,11 @@ uv pip install rf-mcp[web]       # Browser Library + SeleniumLibrary
 uv pip install rf-mcp[mobile]    # AppiumLibrary
 uv pip install rf-mcp[api]       # RequestsLibrary
 uv pip install rf-mcp[database]  # DatabaseLibrary
+uv pip install --pre rf-mcp[desktop]  # PlatynUI new-core (Rust) native desktop — Python 3.12+, prerelease
 uv pip install rf-mcp[frontend]  # Django-based web frontend dashboard
 uv pip install rf-mcp[memory]    # Persistent semantic memory (sqlite-vec + model2vec)
 uv pip install rf-mcp[semantic]  # Sentence-transformers for find_keywords embedding ranking
-uv pip install rf-mcp[all]       # All optional Robot Framework libraries
+uv pip install rf-mcp[all]       # All optional Robot Framework libraries (desktop is separate — prerelease/3.12+)
 
 # Alternatively, add to an existing uv project
 uv init

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rf-mcp"
-version = "0.34.0.dev0"
+version = "0.34.0.dev2"
 description = "Robot Framework MCP Server - Natural Language Test Automation Bridge"
 authors = [{ name = "Many Kasiriha" }]
 license = { text = "Apache-2.0" }
@@ -28,6 +28,21 @@ frontend = ["django>=4.2,<5.0", "uvicorn[standard]>=0.24"]
 mobile = ["robotframework-appiumlibrary"]
 api = ["robotframework-requests"]
 database = ["robotframework-databaselibrary"]
+# PlatynUI new-core (Rust) native desktop automation (ADR-025). These are DEV
+# PRERELEASES tracking the latest Rust core and REQUIRE Python 3.12+ (the native
+# core ships cp312-abi3 wheels; robotframework-PlatynUI declares requires-python
+# >=3.12). The `python_version >= "3.12"` markers keep `pip install rf-mcp[desktop]`
+# resolvable on rf-mcp's 3.10/3.11 baseline (it just installs nothing there).
+# robotframework-PlatynUI pins `platynui-native==<same version>`, so the native
+# Rust core is pulled automatically at the matching version — do NOT pin it
+# separately (that risks a lockstep conflict on the next bump). platynui-cli is the
+# optional diagnostic CLI (window/snapshot/highlight, used by the display-safety
+# probes). Exact-pinned for reproducibility; bump both together to a newer dev.
+# The version references a prerelease, so resolvers accept it WITHOUT a global --pre.
+desktop = [
+    "robotframework-PlatynUI==0.13.0.dev2; python_version >= '3.12'",
+    "platynui-cli==0.13.0.dev2; python_version >= '3.12'",
+]
 memory = ["sqlite-vec>=0.1.6", "model2vec>=0.4.0"]
 tokens = ["tiktoken>=0.7.0"]
 # OBS-30 / lazy-offline-embeddings — semantic find_keywords ranking runs on a

{rf_mcp-0.34.0.dev0 → 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.dev0 → 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.dev0 → 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()