seleniumboot-mcp 0.2.1__tar.gz → 0.2.2__tar.gz

{seleniumboot_mcp-0.2.1 → seleniumboot_mcp-0.2.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: seleniumboot-mcp
-Version: 0.2.1
+Version: 0.2.2
 Summary: A Python MCP server for Selenium WebDriver — browser automation, Java TestNG/JUnit5/Cucumber codegen, and Page Object Model generation
-Author-email: Panjatan <panjatan.tech@gmail.com>
+Author-email: Raza Tech <razatechnologyservices@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/seleniumboot/selenium-mcp
 Project-URL: Repository, https://github.com/seleniumboot/selenium-mcp

{seleniumboot_mcp-0.2.1 → seleniumboot_mcp-0.2.2}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seleniumboot-mcp"
-version = "0.2.1"
+version = "0.2.2"
 description = "A Python MCP server for Selenium WebDriver — browser automation, Java TestNG/JUnit5/Cucumber codegen, and Page Object Model generation"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
-authors = [{ name = "Panjatan", email = "panjatan.tech@gmail.com" }]
+authors = [{ name = "Raza Tech", email = "razatechnologyservices@gmail.com" }]
 keywords = ["selenium", "mcp", "test-automation", "webdriver", "testng", "junit", "model-context-protocol"]
 classifiers = [
     "Development Status :: 4 - Beta",

{seleniumboot_mcp-0.2.1 → seleniumboot_mcp-0.2.2}/src/selenium_mcp/server.py

@@ -18,6 +18,7 @@ from selenium_mcp.tools.assertion_tools import AssertionTools
 from selenium_mcp.tools.codegen_tools import CodegenTools
 
 _log_path = Path(tempfile.gettempdir()) / "selenium-mcp.log"
+_log_path.touch(mode=0o600, exist_ok=True)
 logging.basicConfig(
     filename=str(_log_path),
     level=logging.DEBUG,

seleniumboot_mcp-0.2.2/src/selenium_mcp/tools/_locators.py

@@ -0,0 +1,14 @@
+"""Shared locator strategy map — imported by element_tools and assertion_tools."""
+
+from selenium.webdriver.common.by import By
+
+BY_MAP = {
+    "css":          By.CSS_SELECTOR,
+    "xpath":        By.XPATH,
+    "id":           By.ID,
+    "name":         By.NAME,
+    "tag":          By.TAG_NAME,
+    "class":        By.CLASS_NAME,
+    "link":         By.LINK_TEXT,
+    "partial_link": By.PARTIAL_LINK_TEXT,
+}

{seleniumboot_mcp-0.2.1/src → seleniumboot_mcp-0.2.2/src/selenium_mcp}/tools/assertion_tools.py

@@ -7,17 +7,7 @@ from selenium.webdriver.common.by import By
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
 from mcp.types import Tool
-
-BY_MAP = {
-    "css":          By.CSS_SELECTOR,
-    "xpath":        By.XPATH,
-    "id":           By.ID,
-    "name":         By.NAME,
-    "tag":          By.TAG_NAME,
-    "class":        By.CLASS_NAME,
-    "link":         By.LINK_TEXT,
-    "partial_link": By.PARTIAL_LINK_TEXT,
-}
+from selenium_mcp.tools._locators import BY_MAP
 
 
 class AssertionTools:
@@ -174,7 +164,7 @@ class AssertionTools:
     async def _assert_url(self, args: dict) -> str:
         actual = self._driver().current_url
         exp = args["expected"]
-        ok = (actual == exp) if args.get("exact", False) else (exp in actual)
+        ok = (actual == exp) if args.get("exact", False) else (exp.lower() in actual.lower())
         return self._pass(f"url='{actual}'") if ok else self._fail(f"expected='{exp}' | actual='{actual}'")
 
     async def _assert_text(self, args: dict) -> str:

{seleniumboot_mcp-0.2.1/src → seleniumboot_mcp-0.2.2/src/selenium_mcp}/tools/browser_tools.py

@@ -27,7 +27,8 @@ class BrowserTools:
             opts.add_argument("--no-sandbox")
             opts.add_argument("--disable-dev-shm-usage")
             self.driver = webdriver.Chrome(options=opts)
-            self._session_log = []
+            # Do NOT reset _session_log here — only explicit start_browser should do that.
+            # Resetting here would wipe recorded actions if the browser crashes mid-session.
             self.record("start_browser", browser="chrome", headless=False)
         return self.driver
 
@@ -165,9 +166,9 @@ class BrowserTools:
         headless = args.get("headless", False)
         try:
             w, h = args.get("window_size", "1920x1080").lower().replace(" ", "").split("x")
-            int(w), int(h)
+            w, h = int(w), int(h)
         except (ValueError, AttributeError):
-            w, h = "1920", "1080"
+            w, h = 1920, 1080
 
         if browser == "chrome":
             opts = ChromeOptions()

{seleniumboot_mcp-0.2.1 → seleniumboot_mcp-0.2.2}/src/selenium_mcp/tools/codegen_tools.py

@@ -3,6 +3,8 @@ Codegen Tools — generate Python (pytest) and Java (TestNG/JUnit5) test scripts
 from the recorded session log. This is the key differentiator for Java users.
 """
 
+import re
+from urllib.parse import urlparse
 from mcp.types import Tool
 
 
@@ -477,14 +479,12 @@ public class {test_name} {{
 
     def _url_to_page_name(self, url: str) -> str:
         try:
-            from urllib.parse import urlparse
             segment = urlparse(url).path.strip("/").split("/")[-1]
             return segment.capitalize() if segment else "Home"
         except Exception:
             return "Recorded"
 
     def _selector_to_name(self, selector: str, by: str) -> str:
-        import re
         sel = selector.strip()
         if by in ("id", "name"):
             return self._to_camel(sel)
@@ -516,7 +516,6 @@ public class {test_name} {{
         return "element"
 
     def _to_camel(self, s: str) -> str:
-        import re
         parts = [p for p in re.split(r"[_\-\s]+", s.strip()) if p]
         return (parts[0].lower() + "".join(p.capitalize() for p in parts[1:])) if parts else "element"
 
@@ -629,6 +628,14 @@ public class {test_name} {{
                     f"{i}}}",
                     "",
                 ]
+            if "right_click" in acts:
+                lines += [
+                    f"{i}public {page_name} rightClick{cap}() {{",
+                    f"{i}{i}new Actions(driver).contextClick(wait.until(ExpectedConditions.visibilityOfElementLocated({name}))).perform();",
+                    f"{i}{i}return this;",
+                    f"{i}}}",
+                    "",
+                ]
             if "scroll_to_element" in acts:
                 lines += [
                     f"{i}public {page_name} scrollTo{cap}() {{",
@@ -772,7 +779,6 @@ public class {test_name} {{
         )
 
     def _name_to_readable(self, name: str) -> str:
-        import re
         return re.sub(r'([A-Z])', r' \1', name).strip().lower()
 
     def _gherkin_step_text(self, entry: dict, key_to_name: dict, prefix: str) -> str:
@@ -918,6 +924,15 @@ public class {test_name} {{
                         f'{i}{i}driver.navigate().back();\n'
                         f'{i}}}'
                     )
+            elif action == "go_forward":
+                if "go_forward" not in seen:
+                    seen.add("go_forward")
+                    methods.append(
+                        f'{i}@And("I navigate forward")\n'
+                        f'{i}public void iNavigateForward() {{\n'
+                        f'{i}{i}driver.navigate().forward();\n'
+                        f'{i}}}'
+                    )
             elif action == "refresh":
                 if "refresh" not in seen:
                     seen.add("refresh")

{seleniumboot_mcp-0.2.1/src → seleniumboot_mcp-0.2.2/src/selenium_mcp}/tools/element_tools.py

@@ -7,18 +7,7 @@ from selenium.webdriver.common.action_chains import ActionChains
 from selenium.webdriver.support.ui import WebDriverWait, Select
 from selenium.webdriver.support import expected_conditions as EC
 from mcp.types import Tool
-
-
-BY_MAP = {
-    "css":    By.CSS_SELECTOR,
-    "xpath":  By.XPATH,
-    "id":     By.ID,
-    "name":   By.NAME,
-    "tag":    By.TAG_NAME,
-    "class":  By.CLASS_NAME,
-    "link":   By.LINK_TEXT,
-    "partial_link": By.PARTIAL_LINK_TEXT,
-}
+from selenium_mcp.tools._locators import BY_MAP
 
 LOCATOR_SCHEMA = {
     "selector": {
@@ -273,7 +262,9 @@ class ElementTools:
         if args.get("clear_first", True):
             el.clear()
         el.send_keys(args["text"])
-        self.browser.record("type_text", selector=args["selector"], by=args.get("by", "css"), text=args["text"])
+        sel_lower = args["selector"].lower()
+        logged_text = "***" if any(k in sel_lower for k in ("password", "passwd", "pwd")) else args["text"]
+        self.browser.record("type_text", selector=args["selector"], by=args.get("by", "css"), text=logged_text)
         return f"✅ Typed into '{args['selector']}'"
 
     async def _get_text(self, args: dict) -> str:
@@ -323,8 +314,9 @@ class ElementTools:
     async def _drag_and_drop(self, args: dict) -> str:
         by = self._by(args.get("by", "css"))
         driver = self.browser.get_driver()
-        src = driver.find_element(by, args["source_selector"])
-        tgt = driver.find_element(by, args["target_selector"])
+        timeout = args.get("timeout", 10)
+        src = WebDriverWait(driver, timeout).until(EC.presence_of_element_located((by, args["source_selector"])))
+        tgt = WebDriverWait(driver, timeout).until(EC.presence_of_element_located((by, args["target_selector"])))
         ActionChains(driver).drag_and_drop(src, tgt).perform()
         return f"✅ Dragged '{args['source_selector']}' → '{args['target_selector']}'"
 

{seleniumboot_mcp-0.2.1 → seleniumboot_mcp-0.2.2}/src/seleniumboot_mcp.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: seleniumboot-mcp
-Version: 0.2.1
+Version: 0.2.2
 Summary: A Python MCP server for Selenium WebDriver — browser automation, Java TestNG/JUnit5/Cucumber codegen, and Page Object Model generation
-Author-email: Panjatan <panjatan.tech@gmail.com>
+Author-email: Raza Tech <razatechnologyservices@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/seleniumboot/selenium-mcp
 Project-URL: Repository, https://github.com/seleniumboot/selenium-mcp

{seleniumboot_mcp-0.2.1 → seleniumboot_mcp-0.2.2}/src/seleniumboot_mcp.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 src/selenium_mcp/__init__.py
 src/selenium_mcp/server.py
 src/selenium_mcp/tools/__init__.py
+src/selenium_mcp/tools/_locators.py
 src/selenium_mcp/tools/assertion_tools.py
 src/selenium_mcp/tools/browser_tools.py
 src/selenium_mcp/tools/codegen_tools.py
@@ -12,8 +13,4 @@ src/seleniumboot_mcp.egg-info/SOURCES.txt
 src/seleniumboot_mcp.egg-info/dependency_links.txt
 src/seleniumboot_mcp.egg-info/entry_points.txt
 src/seleniumboot_mcp.egg-info/requires.txt
-src/seleniumboot_mcp.egg-info/top_level.txt
-src/tools/assertion_tools.py
-src/tools/browser_tools.py
-src/tools/codegen_tools.py
-src/tools/element_tools.py
+src/seleniumboot_mcp.egg-info/top_level.txt

{seleniumboot_mcp-0.2.1 → seleniumboot_mcp-0.2.2}/src/seleniumboot_mcp.egg-info/top_level.txt

@@ -1,2 +1 @@
 selenium_mcp
-tools

seleniumboot_mcp-0.2.1/src/selenium_mcp/tools/assertion_tools.py

@@ -1,245 +0,0 @@
-"""
-Assertion Tools — validate page state, element state, text, URL, title
-Returns PASS/FAIL with detail — useful for AI-driven test verification.
-"""
-
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from mcp.types import Tool
-
-BY_MAP = {
-    "css":          By.CSS_SELECTOR,
-    "xpath":        By.XPATH,
-    "id":           By.ID,
-    "name":         By.NAME,
-    "tag":          By.TAG_NAME,
-    "class":        By.CLASS_NAME,
-    "link":         By.LINK_TEXT,
-    "partial_link": By.PARTIAL_LINK_TEXT,
-}
-
-
-class AssertionTools:
-    def __init__(self, browser_tools):
-        self.browser = browser_tools
-
-    def _driver(self):
-        return self.browser.get_driver()
-
-    def _by(self, strategy: str):
-        return BY_MAP.get(strategy, By.CSS_SELECTOR)
-
-    def get_tools(self) -> list[Tool]:
-        return [
-            Tool(
-                name="assert_title",
-                description="Assert the page title equals or contains expected text.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "expected": {"type": "string"},
-                        "exact": {"type": "boolean", "default": False}
-                    },
-                    "required": ["expected"],
-                },
-            ),
-            Tool(
-                name="assert_url",
-                description="Assert the current URL equals or contains expected value.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "expected": {"type": "string"},
-                        "exact": {"type": "boolean", "default": False}
-                    },
-                    "required": ["expected"],
-                },
-            ),
-            Tool(
-                name="assert_text",
-                description="Assert element text equals or contains expected value.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "selector": {"type": "string"},
-                        "by": {"type": "string", "default": "css"},
-                        "expected": {"type": "string"},
-                        "exact": {"type": "boolean", "default": False},
-                        "timeout": {"type": "integer", "default": 10}
-                    },
-                    "required": ["selector", "expected"],
-                },
-            ),
-            Tool(
-                name="assert_element_visible",
-                description="Assert an element is visible on the page.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "selector": {"type": "string"},
-                        "by": {"type": "string", "default": "css"},
-                        "timeout": {"type": "integer", "default": 10}
-                    },
-                    "required": ["selector"],
-                },
-            ),
-            Tool(
-                name="assert_element_not_visible",
-                description="Assert an element is NOT visible (hidden or absent).",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "selector": {"type": "string"},
-                        "by": {"type": "string", "default": "css"},
-                        "timeout": {"type": "integer", "default": 3}
-                    },
-                    "required": ["selector"],
-                },
-            ),
-            Tool(
-                name="assert_attribute",
-                description="Assert an element attribute has the expected value.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "selector": {"type": "string"},
-                        "by": {"type": "string", "default": "css"},
-                        "attribute": {"type": "string"},
-                        "expected": {"type": "string"},
-                        "exact": {"type": "boolean", "default": True},
-                        "timeout": {"type": "integer", "default": 10}
-                    },
-                    "required": ["selector", "attribute", "expected"],
-                },
-            ),
-            Tool(
-                name="assert_page_contains",
-                description="Assert the full page source or visible text contains a string.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "text": {"type": "string"},
-                        "source_only": {
-                            "type": "boolean",
-                            "default": False,
-                            "description": "If true, checks page source; otherwise checks body visible text"
-                        }
-                    },
-                    "required": ["text"],
-                },
-            ),
-            Tool(
-                name="assert_element_count",
-                description="Assert number of elements matching selector equals expected count.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "selector": {"type": "string"},
-                        "by": {"type": "string", "default": "css"},
-                        "expected_count": {"type": "integer"}
-                    },
-                    "required": ["selector", "expected_count"],
-                },
-            ),
-        ]
-
-    def get_handlers(self) -> dict:
-        return {
-            "assert_title":               self._assert_title,
-            "assert_url":                 self._assert_url,
-            "assert_text":                self._assert_text,
-            "assert_element_visible":     self._assert_element_visible,
-            "assert_element_not_visible": self._assert_element_not_visible,
-            "assert_attribute":           self._assert_attribute,
-            "assert_page_contains":       self._assert_page_contains,
-            "assert_element_count":       self._assert_element_count,
-        }
-
-    # ------------------------------------------------------------------ #
-    #  Helpers                                                             #
-    # ------------------------------------------------------------------ #
-    def _pass(self, msg): return f"✅ PASS | {msg}"
-    def _fail(self, msg): return f"❌ FAIL | {msg}"
-
-    # ------------------------------------------------------------------ #
-    #  Handlers                                                            #
-    # ------------------------------------------------------------------ #
-    async def _assert_title(self, args: dict) -> str:
-        actual = self._driver().title
-        exp = args["expected"]
-        ok = (actual == exp) if args.get("exact", False) else (exp.lower() in actual.lower())
-        return self._pass(f"title='{actual}'") if ok else self._fail(f"expected='{exp}' | actual='{actual}'")
-
-    async def _assert_url(self, args: dict) -> str:
-        actual = self._driver().current_url
-        exp = args["expected"]
-        ok = (actual == exp) if args.get("exact", False) else (exp in actual)
-        return self._pass(f"url='{actual}'") if ok else self._fail(f"expected='{exp}' | actual='{actual}'")
-
-    async def _assert_text(self, args: dict) -> str:
-        by = self._by(args.get("by", "css"))
-        timeout = args.get("timeout", 10)
-        try:
-            el = WebDriverWait(self._driver(), timeout).until(
-                EC.visibility_of_element_located((by, args["selector"]))
-            )
-        except Exception:
-            return self._fail(f"element '{args['selector']}' not found within {timeout}s")
-        actual = el.text
-        exp = args["expected"]
-        ok = (actual == exp) if args.get("exact", False) else (exp.lower() in actual.lower())
-        return self._pass(f"text='{actual}'") if ok else self._fail(f"expected='{exp}' | actual='{actual}'")
-
-    async def _assert_element_visible(self, args: dict) -> str:
-        by = self._by(args.get("by", "css"))
-        timeout = args.get("timeout", 10)
-        try:
-            WebDriverWait(self._driver(), timeout).until(
-                EC.visibility_of_element_located((by, args["selector"]))
-            )
-            return self._pass(f"'{args['selector']}' is visible")
-        except Exception:
-            return self._fail(f"'{args['selector']}' is NOT visible")
-
-    async def _assert_element_not_visible(self, args: dict) -> str:
-        by = self._by(args.get("by", "css"))
-        timeout = args.get("timeout", 3)
-        try:
-            WebDriverWait(self._driver(), timeout).until(
-                EC.invisibility_of_element_located((by, args["selector"]))
-            )
-            return self._pass(f"'{args['selector']}' is not visible")
-        except Exception:
-            return self._fail(f"'{args['selector']}' IS visible (expected hidden)")
-
-    async def _assert_attribute(self, args: dict) -> str:
-        by = self._by(args.get("by", "css"))
-        timeout = args.get("timeout", 10)
-        try:
-            el = WebDriverWait(self._driver(), timeout).until(
-                EC.presence_of_element_located((by, args["selector"]))
-            )
-        except Exception:
-            return self._fail(f"element '{args['selector']}' not found within {timeout}s")
-        actual = el.get_attribute(args["attribute"])
-        exp = args["expected"]
-        ok = (actual == exp) if args.get("exact", True) else (exp in (actual or ""))
-        return self._pass(f"{args['attribute']}='{actual}'") if ok else self._fail(f"expected='{exp}' | actual='{actual}'")
-
-    async def _assert_page_contains(self, args: dict) -> str:
-        text = args["text"]
-        if args.get("source_only", False):
-            content = self._driver().page_source
-        else:
-            content = self._driver().find_element(By.TAG_NAME, "body").text
-        ok = text.lower() in content.lower()
-        return self._pass(f"page contains '{text}'") if ok else self._fail(f"'{text}' not found on page")
-
-    async def _assert_element_count(self, args: dict) -> str:
-        by = self._by(args.get("by", "css"))
-        els = self._driver().find_elements(by, args["selector"])
-        actual = len(els)
-        exp = args["expected_count"]
-        ok = actual == exp
-        return self._pass(f"count={actual}") if ok else self._fail(f"expected={exp} | actual={actual}")