repld-tool 0.3.1__tar.gz → 0.3.2__tar.gz

{repld_tool-0.3.1 → repld_tool-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repld-tool
-Version: 0.3.1
+Version: 0.3.2
 Summary: Persistent Python runtime with MCP channel push. Dev shell and autonomous-agent substrate in one package.
 Keywords: repl,mcp,agent,browser
 Author: Fredrik Angelsen

{repld_tool-0.3.1 → repld_tool-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "repld-tool"
-version = "0.3.1"
+version = "0.3.2"
 description = "Persistent Python runtime with MCP channel push. Dev shell and autonomous-agent substrate in one package."
 readme = "README.md"
 authors = [

{repld_tool-0.3.1 → repld_tool-0.3.2}/src/repld/bridge.py

@@ -334,10 +334,9 @@ class Bridge:
             return True
 
         if method == "ping":
-            # A liveness probe deserves a real answer, and answering it is
-            # exactly as honest with no kernel as with one — the bridge is the
-            # thing being pinged. Must not fall through: anything the intercept
-            # declines that isn't in _NEEDS_KERNEL is answered -32601.
+            # Answered here, not by a kernel — the bridge is the thing being
+            # pinged. Must not fall through: anything the intercept declines
+            # that isn't in _NEEDS_KERNEL is answered -32601.
             self._to_client(_response(rid, {}))
             return True
 

{repld_tool-0.3.1 → repld_tool-0.3.2}/src/repld/browser/selector.py

@@ -43,7 +43,20 @@ _ROLE_CSS: dict[str, str] = {
 # identifiers. Anchored and dot-free, so a real expression (`window.ready`,
 # `app.isLoaded`) still reads as JS.
 _BARE_NAME = re.compile(r"^[A-Za-z][A-Za-z0-9-]*$")
-_SELECTOR_PREFIXES = (".", "#", "[", "data-", "text=", "role=", "label=", "aria-ref=")
+_SELECTOR_PREFIXES = (
+    ".",
+    "#",
+    "[",
+    "data-",
+    "text=",
+    "role=",
+    "label=",
+    "aria-ref=",
+    "placeholder=",
+    "testid=",
+    "getBy",
+    "locator(",
+)
 
 
 def looks_like_selector(s: str) -> bool:
@@ -56,12 +69,9 @@ def looks_like_selector(s: str) -> bool:
 
 
 def _q(text: str) -> str:
-    # ensure_ascii=False is load-bearing, everywhere this module quotes user
-    # text: json.dumps' default emits å-style escapes, and the engine's
-    # selector parser reads those as six literal characters — so every
-    # selector carrying a non-ASCII name (`text=Pågår`, a Norwegian label)
-    # matched nothing. Found live on a real page; the raw engine matched what
-    # the translated selector missed.
+    # ensure_ascii=False is load-bearing: the engine's selector parser reads
+    # json.dumps' default \u-escapes as literal characters, so `text=Pågår`
+    # would match nothing.
     return json.dumps(text, ensure_ascii=False)
 
 
@@ -81,6 +91,59 @@ def _js_regex_escape(text: str) -> str:
 _ROLE_RE = re.compile(r'^role=(\w+)(?:\[name([*^]?=)["\']?(.+?)["\']?\])?$')
 _HAS_TEXT_RE = re.compile(r"^(.+?):has-text\(['\"](.+?)['\"]\)$")
 
+# Playwright locator syntax, accepted as *input* so the strict-mode error's own
+# suggestions (`aka getByTestId('x')`) are pasteable back into click/type.
+# Mirrors packages/isomorphic/locatorUtils.ts' getBy*Selector builders — only
+# the simple single-call forms; chains (`.filter()`, `>>`) error with guidance
+# rather than falling through to css= and failing as nonsense.
+_GETBY_RE = re.compile(
+    r"^(getByRole|getByTestId|getByText|getByLabel|getByPlaceholder"
+    r"|getByAltText|getByTitle|locator)\s*\((.*)\)\s*$",
+    re.S,
+)
+_GETBY_ARGS_RE = re.compile(
+    r"""^\s*(['"])(?P<v>(?:\\.|(?!\1).)*)\1\s*(?:,\s*\{(?P<opts>.*)\}\s*)?$""",
+    re.S,
+)
+_GETBY_NAME_RE = re.compile(r"""name\s*:\s*(['"])(?P<v>(?:\\.|(?!\1).)*)\1""")
+_GETBY_EXACT_RE = re.compile(r"exact\s*:\s*true")
+
+
+def _unescape(v: str) -> str:
+    return re.sub(r"\\(.)", r"\1", v)
+
+
+def _translate_getby(fn: str, args: str) -> list[str]:
+    m = _GETBY_ARGS_RE.match(args)
+    if m is None:
+        raise ValueError(
+            f"cannot parse {fn}({args!r}) — only the simple quoted-argument "
+            "forms are supported (no chaining, no regex/variable arguments)"
+        )
+    value = _unescape(m.group("v"))
+    opts = m.group("opts") or ""
+    exact = bool(_GETBY_EXACT_RE.search(opts))
+    if fn == "locator":
+        return translate_fallbacks(value)
+    if fn == "getByTestId":
+        return [f"internal:testid=[data-testid={_text_body(value, exact=True)}]"]
+    if fn == "getByRole":
+        name_m = _GETBY_NAME_RE.search(opts)
+        if name_m is None:
+            return [f"role={value}"]
+        name = _unescape(name_m.group("v"))
+        return [f"role={value}[name={_text_body(name, exact=exact)}]"]
+    if fn == "getByText":
+        return [f"internal:text={_text_body(value, exact=exact)}"]
+    if fn == "getByLabel":
+        return [f"internal:label={_text_body(value, exact=exact)}"]
+    attr = {
+        "getByPlaceholder": "placeholder",
+        "getByAltText": "alt",
+        "getByTitle": "title",
+    }[fn]
+    return [f"internal:attr=[{attr}={_text_body(value, exact=exact)}]"]
+
 
 def translate(selector: str) -> str:
     """Translate one repld selector to the engine's selector language."""
@@ -98,9 +161,8 @@ def translate_fallbacks(selector: str) -> list[str]:
     if selector.startswith("text="):
         text = selector[5:]
         # internal:text, not the public text= engine: only the internal one
-        # accepts the `"…"s` exact-case-sensitive body, which is what matches
-        # the legacy `===` semantics (verified live — the public engine parses
-        # `text="Save"s` as the literal string `"Save"s` and matches nothing).
+        # accepts the `"…"s` exact body — the public engine parses
+        # `text="Save"s` as the literal string `"Save"s` and matches nothing.
         return [
             f"internal:text={_text_body(text, exact=True)}",
             f"css=[aria-label={_q(text)}]",
@@ -123,6 +185,16 @@ def translate_fallbacks(selector: str) -> list[str]:
     if selector.startswith("label="):
         return [f"internal:label={_text_body(selector[6:], exact=True)}"]
 
+    if selector.startswith("placeholder="):
+        return [f"internal:attr=[placeholder={_text_body(selector[12:], exact=True)}]"]
+
+    if selector.startswith("testid="):
+        return [f"internal:testid=[data-testid={_text_body(selector[7:], exact=True)}]"]
+
+    m = _GETBY_RE.match(selector)
+    if m:
+        return _translate_getby(m.group(1), m.group(2))
+
     m = _HAS_TEXT_RE.match(selector)
     if m:
         base, text = m.group(1), m.group(2)

{repld_tool-0.3.1 → repld_tool-0.3.2}/src/repld/browser/tab.py

@@ -552,6 +552,18 @@ class Tab(TabQueryMixin):
         if result.get("result", {}).get("value") == "hidden":
             await self._exec("Page.bringToFront")
 
+    async def set_viewport(self, width: int, height: int) -> None:
+        """Emulate a fixed viewport (Emulation.setDeviceMetricsOverride).
+
+        deviceScaleFactor pinned to 1 so page pixels are screenshot pixels.
+        Use a fresh tab per distinct size — re-overriding an already-
+        overridden tab can leave clientWidth and innerWidth disagreeing.
+        """
+        await self._exec(
+            "Emulation.setDeviceMetricsOverride",
+            {"width": width, "height": height, "deviceScaleFactor": 1, "mobile": False},
+        )
+
     async def front(self) -> None:
         """Bring this tab's window to the front (Page.bringToFront).
 
@@ -649,13 +661,23 @@ class Tab(TabQueryMixin):
     async def _element_center_of(
         self, el: inject.ResolvedElement, selector: str
     ) -> tuple[float, float]:
-        """Center point of a resolved element handle.
+        """Center point of a resolved element handle, scrolled into view first.
+
+        The scroll is load-bearing: quads are viewport coordinates and
+        clipping isn't visibility, so an element below a scroll fold (the
+        page's or a scrollable listbox's) passes the visible check while its
+        center lies outside the clip — a click there hits whatever is
+        actually at that point. Best-effort: a detached or unscrollable node
+        falls through to the hit test.
 
         DOM.getContentQuads returns no quads for a zero-area element; the
-        bounding-rect fallback keeps the single-hidden-match case (an
-        off-screen real control behind a styled proxy) addressable, matching
-        the resolve policy that a lone invisible match is still the target.
+        bounding-rect fallback keeps a lone hidden match (an off-screen real
+        control behind a styled proxy) addressable, per the resolve policy.
         """
+        try:
+            await self._exec("DOM.scrollIntoViewIfNeeded", {"objectId": el.object_id})
+        except RuntimeError:
+            pass
         quads = await self._exec("DOM.getContentQuads", {"objectId": el.object_id})
         qs = quads.get("quads") or []
         if qs:
@@ -700,18 +722,13 @@ class Tab(TabQueryMixin):
         """Coordinate resolution + hit receipt + dispatch for a resolved element.
 
         The hit test runs *before* dispatch — the click's own handlers may
-        re-render the DOM, so "what will this land on" is the honest answer.
-        When the point lands on something unrelated to the target, a plain
-        left-click switches to `element.click()` instead of dispatching at the
-        coordinates: the coordinate path is worse than a no-op there (on a
-        drag/pan layer it can start a drag), while a DOM click reaches the
-        resolved element the way assistive tech does. Found live: a workflow
-        editor's accessible button list sits under its SVG diagram, so the
-        visible, resolvable button was never coordinate-clickable. The DOM
-        click is isTrusted=false — an app that insists on trusted events will
-        ignore it, which is why the receipt names the path taken. Modified
-        clicks (right/double) have no element.click() equivalent, so they keep
-        the coordinate dispatch plus the warning.
+        re-render the DOM. When the point lands on something unrelated, a
+        plain left-click switches to `element.click()`: dispatching at the
+        coordinates can start a drag on a pan layer, while a DOM click
+        reaches the resolved element the way assistive tech does. It is
+        isTrusted=false, so the receipt names the path taken. Modified clicks
+        (right/double) have no element.click() equivalent and keep the
+        coordinate dispatch plus the warning.
         """
         x, y = await self._element_center_of(el, selector)
         data = await inject.hit_receipt(self, el, x, y)
@@ -902,17 +919,43 @@ class Tab(TabQueryMixin):
         await inject.check_actionable(
             self, opt_el, ("visible", "stable"), selector=opt_label
         )
+        # A just-opened menu is still moving: Popper repositions the listbox
+        # after first paint, and the engine's 1-rAF stable check passes inside
+        # that window — a click at the pre-reposition point lands outside the
+        # menu. Sample the option's center 120 ms apart until it stops moving.
+        loop = asyncio.get_running_loop()
+        prev: tuple[float, float] | None = None
+        deadline = loop.time() + 1.5
+        while True:
+            pos = await self._element_center_of(opt_el, opt_label)
+            if (
+                prev is not None
+                and abs(pos[0] - prev[0]) < 1
+                and abs(pos[1] - prev[1]) < 1
+            ):
+                break
+            if loop.time() >= deadline:
+                break
+            prev = pos
+            await asyncio.sleep(0.12)
         await self._click_element(opt_el, selector=opt_label)
 
-        # Best-effort: the field (or its re-rendered value) should now carry
-        # the option text. try/except because the click may have replaced the
-        # field element outright, which detaches our handle — not a failure.
+        # Verify what the widget *renders*: react-select never stores the
+        # choice in input.value and puts role=combobox on the input itself, so
+        # a `closest` self-match walks up two levels to the value container
+        # instead. try/except: the click may have replaced the field element
+        # outright, detaching our handle — not a failure.
         verified = False
         try:
             v = await inject.call_engine(
                 self,
-                "function(el, opt) { const t = (el.value || '') + ' ' +"
-                " (el.textContent || ''); return t.includes(opt); }",
+                "function(el, opt) {"
+                " let root = el.closest('[role=\"combobox\"]');"
+                " if (!root || root === el)"
+                "   root = el.parentElement"
+                "     ? (el.parentElement.parentElement || el.parentElement) : el;"
+                " const t = (el.value || '') + ' ' + (root.textContent || '');"
+                " return t.includes(opt); }",
                 [{"objectId": el.object_id}, {"value": option}],
             )
             verified = bool(v.get("result", {}).get("value"))

{repld_tool-0.3.1 → repld_tool-0.3.2}/src/repld/browser_dispatch.py

@@ -42,6 +42,45 @@ _SETTLE_DEFAULT_S = 3.0
 _POST_TYPE_DEBOUNCE_S = 0.3
 
 
+# Noise control, not redaction — repld's contract is that the agent works with
+# the user's real sessions, so nothing is hidden: `full=true` (or tab.request()
+# in exec) returns everything. The cap only trims the cookie jar and bearer
+# tokens that otherwise dominate every request dump.
+_HEADER_VALUE_CAP = 120
+_COOKIE_VALUE_CAP = 24
+
+
+def _cap(value, limit: int):
+    if not isinstance(value, str) or len(value) <= limit:
+        return value
+    return f"{value[:limit]}…(+{len(value) - limit} chars — full=true for the rest)"
+
+
+def _compact_credentials(entry: dict) -> dict:
+    out = json.loads(json.dumps(entry, default=str))  # deep copy, wire-shaped
+    for side in ("request", "response"):
+        part = out.get(side)
+        if not isinstance(part, dict):
+            continue
+        headers = part.get("headers")
+        if isinstance(headers, dict):
+            for k, v in headers.items():
+                if k.lower() in ("cookie", "set-cookie") and isinstance(v, str):
+                    headers[k] = "; ".join(
+                        f"{n}={_cap(val, _COOKIE_VALUE_CAP)}" if val else pair
+                        for pair in v.split("; ")
+                        for n, _, val in (pair.partition("="),)
+                    )
+                else:
+                    headers[k] = _cap(v, _HEADER_VALUE_CAP)
+        cookies = part.get("cookies")
+        if isinstance(cookies, list):
+            for c in cookies:
+                if isinstance(c, dict) and "value" in c:
+                    c["value"] = _cap(c["value"], _COOKIE_VALUE_CAP)
+    return out
+
+
 async def route_detach(browser, target, port) -> str | None:
     """Shared target/port detach routing (MCP tool + dashboard RPC).
 
@@ -246,7 +285,10 @@ class BrowserDispatchMixin:
 
     def _bh_request(self, browser, args):
         tab = self._get_tab(browser, args)
-        return tab.request(args["request_id"])
+        entry = tab.request(args["request_id"])
+        if args.get("full"):
+            return entry
+        return _compact_credentials(entry)
 
     def _bh_body(self, browser, args):
         tab = self._get_tab(browser, args)
@@ -350,6 +392,9 @@ class BrowserDispatchMixin:
         from .browser.observe import PreObservation, post_observe
 
         tab = self._run_async(browser.open(args["url"]))
+        if args.get("viewport"):
+            w, _, h = str(args["viewport"]).lower().partition("x")
+            self._run_async(tab.set_viewport(int(w), int(h)))
         session = self._session_for(browser, tab)
         key = tab.target_id
         pre = PreObservation(iframe_children=[], snapshots={key: 0})

{repld_tool-0.3.1 → repld_tool-0.3.2}/src/repld/help.py

@@ -519,6 +519,12 @@ Convention: add data-testid to your root layout component.
       3s timeout — raises TimeoutError if the page's touch handler blocks
       (common on complex apps like Messenger/React).
 
+  tab.set_viewport(width, height)                             → None
+      Emulate a fixed viewport at deviceScaleFactor 1
+      (Emulation.setDeviceMetricsOverride), so screenshot coordinates are
+      page pixels with no multiplier math.  browser_open's viewport= param
+      calls this on open.  Use a fresh tab per distinct size.
+
   tab.front()                                                 → None
       Bring this tab's window to the front (Page.bringToFront).
       click/tap/type_text/key already call this automatically when Chrome
@@ -791,8 +797,14 @@ Same syntax across click, tap, type_text, select_option, wait_for:
   text=Submit                                         exact text match
   role=button[name="Save"]                            ARIA role + accessible name
   label=Username                                      input by label
+  placeholder=Search or create                        input by placeholder
+  testid=workflow.add-status                          data-testid shorthand
   button:has-text('OK')                               CSS + text filter
   aria-ref=e12                                        ref from tab.tree() / browser_tree
+  getByRole('button', { name: 'OK' })                 Playwright locator call — what the
+                                                      strict-mode error suggests, pasteable
+                                                      as-is (also getByTestId/getByText/
+                                                      getByLabel/getByPlaceholder/locator)
 
 Resolution runs through a vendored build of Playwright's InjectedScript
 engine, evaluated once per document in an isolated world (main world on the
@@ -1215,6 +1227,7 @@ Tab (async unless noted):
   tab.tree(mode="aria")                            → list[str] (aria: [ref=eN] snapshot; "ax": raw CDP tree)
   tab.click(selector, button=, click_count=)       → Receipt (strict resolve + actionability wait; names what was hit)
   tab.tap(selector_or_x, y=)                       → Receipt (touch event, 3s timeout)
+  tab.set_viewport(width, height)                  → None (fixed viewport at scale 1 — screenshot px == page px)
   tab.front()                                      → None (Page.bringToFront; click/tap/type_text/key auto-call this on a hidden tab)
   tab.swipe(x1, y1, x2, y2, steps=, duration_ms=)  → None (touch scroll)
   tab.scroll(selector, dy=, dx=, steps=, duration_ms=) → None (touch-scroll container)
@@ -1293,8 +1306,11 @@ Selectors (click/tap/type_text/select_option):
   text=Submit                            exact text match
   role=button[name="Save"]              ARIA role + accessible name (accname)
   label=Username                        input by label
+  placeholder=Search                    input by placeholder
+  testid=x                              data-testid shorthand
   button:has-text('OK')                 CSS + text filter
   aria-ref=e12                          ref from tab.tree() (dies on next snapshot/navigation)
+  getByRole('button', { name: 'OK' })   Playwright locator call — ambiguity-error suggestions paste as-is
 
   All forms resolve through the vendored Playwright engine (isolated world,
   once per document) and pierce open shadow roots. Strict: >1 match with no

{repld_tool-0.3.1 → repld_tool-0.3.2}/src/repld/protocol.py

@@ -43,8 +43,10 @@ _TARGET_PARAM = {"type": "string", "description": _TARGET_DESC}
 _SELECTOR_PARAM = {
     "type": "string",
     "description": (
-        "CSS, text=Label, role=button[name='OK'], label=Name, "
-        "tag:has-text('...'), or aria-ref=e12 from browser_tree"
+        "CSS, text=Label, role=button[name='OK'], label=Name, placeholder=Hint, "
+        "testid=x, tag:has-text('...'), aria-ref=e12 from browser_tree, or a "
+        "Playwright locator call as suggested by ambiguity errors "
+        "(getByRole('button', {name: 'OK'}), getByTestId('x'), ...)"
     ),
 }
 
@@ -148,13 +150,17 @@ TOOLS = [
         "description": (
             "Inspect a captured request by request_id. Returns full HAR entry "
             "with request/response headers, postData, auth scheme, timing — "
-            "everything except the response body (use browser_body for that)."
+            "everything except the response body (use browser_body for that). "
+            "Cookie and long header values are truncated by default (noise, "
+            "not secrecy — they dominate every dump); pass full=true, or use "
+            "tab.request(id) in exec, for the verbatim values."
         ),
         "inputSchema": {
             "type": "object",
             "properties": {
                 "target": _TARGET_PARAM,
                 "request_id": {"type": "string"},
+                "full": {"type": "boolean", "default": False},
             },
             "required": ["target", "request_id"],
         },
@@ -196,12 +202,18 @@ TOOLS = [
         "name": "browser_open",
         "description": (
             "Open new tab and navigate. "
-            "Returns observation with target: header for the new tab ID."
+            "Returns observation with target: header for the new tab ID. "
+            "viewport='1440x900' emulates a fixed viewport at scale 1, so "
+            "screenshot coordinates are page pixels with no multiplier math."
         ),
         "inputSchema": {
             "type": "object",
             "properties": {
                 "url": {"type": "string"},
+                "viewport": {
+                    "type": "string",
+                    "description": "Fixed viewport as 'WIDTHxHEIGHT', e.g. '1440x900'",
+                },
             },
             "required": ["url"],
         },