@raultov/browser-control-mcp 0.8.0-beta.12 → 0.10.0-beta.14

package/CHANGELOG.md

@@ -10,6 +10,116 @@ from a copy of its code: entries describe the differences from that release.
 
 ## [Unreleased]
 
+## [0.10.0-beta.14] - 2026-11-01
+
+Public **BETA**. `emulate` gains `user_agent`, `locale`, `timezone` and
+`geolocation` on both browsers, and each call now adds to the earlier ones;
+input actions say when they opened a tab; `evaluate_js` takes top-level
+`await`; Chrome's snapshot reads closed shadow roots. Behaviour changes:
+`navigate` and `reload` fail at once when the page pauses at a breakpoint or
+opens a dialog while loading (Chrome waited 30 s); with a modal `<dialog>`
+open, `snapshot` lists only the dialog; on Firefox a navigation that becomes
+a download fails, as on Chrome; `emulate`'s reply has `user_agent`, `locale`
+and `timezone`.
+
+### Fixed
+
+- Chrome: `snapshot` and `find_in_snapshot` read closed shadow roots (some
+  design systems and third-party widgets), whose elements were invisible:
+  Chrome finds them (`DOM.describeNode` with `pierce`) and hands them to
+  the outline for that call only, so the page's own scripts never get them;
+  their elements are then reached by ref like any other. Pages up to 20 000
+  elements; `host >>> inner` selectors still stop at a closed root. Firefox
+  has no equivalent: there they stay out of reach. (#42)
+- Firefox: `navigate` to a URL Firefox saves rather than opens (a type such
+  as CSV, without `Content-Disposition: attachment`) answered "Navigated
+  to" the previous page; it now fails as a download, as on Chrome, from
+  Firefox's `browsingContext.downloadWillBegin`. (#39)
+- `evaluate_js` takes `await` at the top level (`const r = await
+  fetch(u); r.json()`), answering the last statement's value as a console
+  does: it failed with a SyntaxError on both browsers. A symbol is described
+  as `Symbol(x)` on both (Firefox answered an empty object), and a function
+  on Chrome by its code (it answered `{}`). (#43)
+- `emulate`: each call adds to the earlier ones, for every option (Chrome
+  kept an earlier viewport but dropped the earlier media settings), and it
+  emulates `user_agent`, `locale`, `timezone` and `geolocation` on both
+  browsers (the page is granted the geolocation permission, and the reply
+  says the position it reads). An unknown time zone or locale fails without
+  changing anything (Chrome kept the old zone silently). (#43)
+- `click_element`, `press_key` and the other input tools say when the
+  action opened tabs (a `target=_blank` link, `window.open`), naming each
+  with its URL: the new tab was registered, but nothing told the agent to
+  look at it. (#41)
+- `snapshot` and `find_in_snapshot` show `<progress>` and `<meter>`
+  (`progressbar`, `meter`, with their value as `40/100`), say whether a
+  `<details>` summary is expanded, mark an open modal `<dialog>` `[modal]`,
+  and leave out what the page made inert: `inert` subtrees and, while a
+  modal dialog is open, everything outside it (it was listed, and clicking
+  it failed as covered). (#40)
+- Chrome: `navigate` and `reload` to a page that pauses at a breakpoint
+  while it loads (in the page or in a frame of another origin) waited the
+  whole 30 s, then answered as if the page were slow. They now fail at once
+  naming where it paused, as on Firefox; `resume` lets the page finish
+  loading. A page opening a dialog while it loads (`alert()` in an inline
+  script) fails at once too, pointing to `handle_dialog`. (#45)
+
+## [0.9.0-beta.13] - 2026-11-01
+
+Public **BETA**. Frames of another origin are now observed and debugged, not
+only read and acted in: on Chrome their console messages and requests (bodies
+included) join the tab's logs, and on both browsers the debugger searches their
+scripts, binds breakpoints in them and pauses, steps and resumes there.
+Behaviour changes: a click on a disabled control now fails instead of reporting
+success, a pointer action waits up to 2 s for its element to appear or be
+enabled, date, time, range and colour inputs get their value set rather than
+typed, and on Chrome the scripts of such frames have ids naming the frame
+(`2.17`).
+
+### Fixed
+
+- Chrome: `get_console_logs` and `get_network_logs` now include the
+  console messages and requests of frames of another origin (payment forms,
+  widgets, ads), which run in a process of their own and were missing:
+  each tab attaches to its frames as they appear, before their scripts run,
+  and feeds their messages and requests to the tab's logs (at most 50
+  frames per tab). Their response bodies are read from the frame. Firefox
+  already reported them. (#36)
+- Chrome: the debugger now reaches the scripts of frames of another
+  origin. `search_scripts` finds them (their ids name the frame, `2.17`,
+  as each frame numbers its scripts like the page), `set_breakpoint` by URL
+  or hash binds in every frame (also frames that load later, before their
+  scripts run) and by script id in its frame, and a pause in a frame is
+  reported to the call that caused it, inspected, stepped and resumed
+  there. A frame's own `debugger;` statements are skipped without
+  breakpoints, as the page's. (#36)
+- Firefox: the debugger reaches the scripts of frames of another origin too
+  (Firefox runs them in their own process, with their own thread):
+  `search_scripts` finds them, `set_breakpoint` by URL binds in them, and a
+  pause in a frame is inspected, stepped and resumed in its thread. Needs
+  `bidi-lite` 0.1.5 through `bidi-browser-lite` 0.1.6. (#36)
+- Chrome: a click (or any mouse action) into a frame of another origin
+  right after the page loaded was sometimes lost while reported as done:
+  Chrome routes input to such an out-of-process frame only once it has
+  registered it, and until then the parent page got the event on the
+  `<iframe>`. Before the first mouse event into such a frame, the mouse now
+  moves to the point until the frame sees it (at most about 1 s). (#44)
+- `fill_input` and `fill_form` set `date`, `time`, `datetime-local`,
+  `month`, `week`, `range` and `color` inputs: the text was typed into the
+  date's segments (Chrome held `61031-02-02` for `2026-10-31`; Firefox left
+  it empty), and range and colour inputs were refused. The value is now set
+  through the input's native setter, with `input` and `change` events, in
+  the format each type expects (`YYYY-MM-DD`, `HH:MM`, a number,
+  `#rrggbb`); a range that snaps the value to its step or bounds is noted,
+  and a malformed value fails naming the format, leaving the old one. (#38)
+- `click_element`, `drag` and the checkboxes of `fill_form` no longer
+  report success on a disabled control: its click handler never runs, so
+  they now fail with "is disabled; nothing was clicked" and send no input.
+  They also wait up to 2 s for an element a CSS selector does not find yet,
+  or a control that is disabled, as pages add elements and enable buttons a
+  moment after the previous action; the error says how long it waited. A
+  ref that names nothing, a hidden or a covered element still fail at once,
+  and `hover` on a disabled control works as before. (#37)
+
 ## [0.8.0-beta.12] - 2026-10-31
 
 Public **BETA**. Reaches into frames of another origin (payment forms,

package/README.md

@@ -13,7 +13,7 @@ It is the successor of
 from a copy of its code) and complements Playwright MCP or
 chrome-devtools-mcp with runtime JavaScript debugging on both browsers.
 
-> **Status: BETA (0.8.0-beta.12).** This version contains known bugs and differences
+> **Status: BETA (0.10.0-beta.14).** This version contains known bugs and differences
 > between Chrome and Firefox (see [Limitations and TODO](#limitations-and-todo))
 > and parts that have not been verified (see [Untested](#untested)). Tool
 > replies may change in incompatible ways before 1.0. Please report problems
@@ -37,7 +37,7 @@ Tokens are estimated as characters / 4 for every server.
 | Firefox | **✓ next to Chrome, same tools** | ✓ one browser per server | ✗ |
 | Several browsers and instances at once | **✓** | ✗ | ✗ |
 | Selectors | CSS, snapshot refs, `host >>> inner` into shadow roots and iframes | CSS, snapshot refs | snapshot refs only |
-| Frames of another origin (payment forms, embedded editors) | ✓ in the snapshot, refs `f2e5` for every input tool | ✓ refs `f1e5` | ✗ |
+| Frames of another origin (payment forms, embedded editors) | ✓ in the snapshot, refs `f2e5` for every input tool, their console and network in the tab's logs | ✓ refs `f1e5` | ✗ |
 | Snapshot of a long page | **bounded at 50 000 characters**, `find_in_snapshot` searches the rest | unbounded | unbounded |
 | Waits for the page to react after an action | ✓ ~50 ms when nothing reacts | ✓ ~500 ms | ✓ ~200 ms |
 | Clicking a covered or hidden element | **fails at once, naming the overlay** | fails after a 5 s timeout | reports success (the overlay gets the click) |
@@ -119,25 +119,25 @@ see the note.
 | `close_tab` | ✓ | ✓ | |
 | `list_tabs` | ✓ | ✓ | |
 | `switch_tab` | ✓ | ✓ | |
-| `navigate` | ✓ | ✓ | `history: "back"` or `"forward"` instead of `url` moves one entry in the tab's history and waits for the page to load (also when it comes from the back-forward cache, which fires no `load`); at either end it fails without moving |
-| `reload` | ✓ | ✓ | |
+| `navigate` | ✓ | ✓ | `history: "back"` or `"forward"` instead of `url` moves one entry in the tab's history and waits for the page to load (also when it comes from the back-forward cache, which fires no `load`); at either end it fails without moving; a URL the browser saves instead of opening (a download: `Content-Disposition: attachment`, or a type such as CSV) fails saying so, and the tab stays where it was; a page that pauses at a breakpoint or opens a dialog while loading fails at once naming it (see `resume`, `handle_dialog`) |
+| `reload` | ✓ | ✓ | a pause or a dialog while loading fails at once, as with `navigate` |
 | `scroll` | ✓ | ✓ | reports the window positions before and after |
-| `emulate` | ✓ | partial | `emulation` group; `width`/`height`, `device_scale_factor`, `mobile` (touch), `color_scheme`, `reduced_motion`, `forced_colors`, `media` (`print`), `reset`; answers what the page now sees; Firefox: viewport and device pixel ratio only (BiDi has no media or touch emulation yet; those options fail naming them) |
+| `emulate` | ✓ | partial | `emulation` group; `width`/`height`, `device_scale_factor`, `mobile` (touch), `color_scheme`, `reduced_motion`, `forced_colors`, `media` (`print`), `user_agent`, `locale`, `timezone` (checked by the page's `Intl` first), `geolocation` (the page is granted the permission to read it), `reset`; each call adds to the earlier ones; answers what the page now sees (with the position it reads); Firefox: no `mobile` or media options (BiDi has no media or touch emulation yet; they fail naming them) |
 | `wait_for` | ✓ | ✓ | waits (checking every 100 ms, at most 30 s) until a visible text appears or is gone, a selector is `visible` / `hidden` / `attached` / `detached`, or the URL contains a text; a dialog or debugger pause ends the wait at once |
 | `inspect_dom` | ✓ | ✓ | includes open shadow roots and same-origin iframes (cross-origin ones are noted); at most 100 000 characters without `query` (cut in the page) |
-| `snapshot` | ✓ | ✓ | outline of the page: role, name, states, value and a ref (`e12`) per element, through open shadow roots and same-origin iframes; frames of another origin are read too (at most 20, 5 deep), their iframe marked `[frame=f2]` and their refs prefixed (`f2e5`), and `selector: "f2"` outlines one; tables without headers (`th`, `thead`, `caption`) are layout and leave only their content, and a cell is named by its text only when it holds nothing else; comboboxes, spinbuttons and sliders built with ARIA show their value (the field's text, `aria-valuetext` or `aria-valuenow`, the option a button-like combobox shows); an element that is only clickable (a handler or a pointer cursor) is one named line, unless it holds links, buttons or fields, which are listed under it; at most 50 000 characters (`selector` and `depth` narrow it); the same JavaScript on both browsers |
+| `snapshot` | ✓ | ✓ | outline of the page: role, name, states, value and a ref (`e12`) per element, through open shadow roots and same-origin iframes, and on Chrome closed shadow roots too (pages up to 20 000 elements; their elements are reached by ref, not by `>>>`); frames of another origin are read too (at most 20, 5 deep), their iframe marked `[frame=f2]` and their refs prefixed (`f2e5`), and `selector: "f2"` outlines one; tables without headers (`th`, `thead`, `caption`) are layout and leave only their content, and a cell is named by its text only when it holds nothing else; comboboxes, spinbuttons and sliders built with ARIA show their value (the field's text, `aria-valuetext` or `aria-valuenow`, the option a button-like combobox shows), progress bars and meters theirs (`40/100`), and a `<details>` summary `[expanded=true|false]`; what the page made inert is left out: `inert` subtrees and, while a modal `<dialog>` is open (marked `[modal]`), everything outside it; an element that is only clickable (a handler or a pointer cursor) is one named line, unless it holds links, buttons or fields, which are listed under it; at most 50 000 characters (`selector` and `depth` narrow it); the same JavaScript on both browsers |
 | `find_in_snapshot` | ✓ | ✓ | `text` (case-insensitive) or `regex` over the whole outline; matching lines under their ancestors, at most 20 |
 | `save_pdf` | ✓ | ✓ | `files` group; prints the tab as the browser's print does (`landscape`, `print_background`, `scale` 0.1–2, `page_ranges` like `1-3, 5`); with `path` (an absolute `.pdf` under the upload roots) writes the file and answers `{path, bytes, pages}`, else returns the PDF as an embedded `application/pdf` resource (at most 5 MB); Chrome `Page.printToPDF`, Firefox `browsingContext.print` |
 | `capture_screenshot` | ✓ | ✓ | `format` `png`, `jpeg` (or `jpg`) or `webp`; `full_page` at most 16 384 px per side (a text note says when cut); `selector` captures one element (CSS, `host >>> inner` or a snapshot ref), scrolled into view, whole even when taller than the viewport |
-| `click_element` | ✓ | ✓ | scrolls the element into view; `button` (left/right/middle), `click_count` (2 = double click) and `modifiers`; fails without clicking when it is hidden or covered (its own label on top does not count: styled checkboxes and switches are clicked through it; a covered element first gets the mouse, so controls shown only on hover are revealed and clicked); `host >>> inner` selectors reach open shadow roots and same-origin iframes (also in `fill_input`, `scroll`, `wait_for`); a dialog or debugger pause the click causes is noted in a successful reply (`{dialog}` or `{paused, location}`) |
-| `fill_input` | ✓ | ✓ | picks `<select>` options; fails without typing on elements that cannot take the text; `append: true` types after the content instead of replacing it (a number, email or date field, which has no caret, is retyped whole); an editor of its own (an element with an `EditContext` or a focusable `textbox` role, or the hidden input of a code editor such as Monaco or Ace) gets the keys a user presses: a click on the editor when its input has no visible box, Control+A (Command+A on macOS) or Control+End, then the text, and the reply says its content could not be checked; in a contenteditable element (including rich text editors such as Slate, Lexical, ProseMirror or CodeMirror 6) it selects the content (a range, then Control+A as a user would) and types over it, so the editor records the edit; types key by key on both (key handlers run; newlines and tabs inserted as text), about 1 ms per character; `change` on leaving the field, or at the end when the window has no focus |
+| `click_element` | ✓ | ✓ | scrolls the element into view; `button` (left/right/middle), `click_count` (2 = double click) and `modifiers`; fails without clicking when it is hidden, covered (its own label on top does not count: styled checkboxes and switches are clicked through it; a covered element first gets the mouse, so controls shown only on hover are revealed and clicked) or a disabled control, whose handler would never run; an element a CSS selector does not find yet, or a disabled control, is checked again for up to 2 s, as pages add elements and enable buttons a moment after the previous action (a ref that names nothing, a hidden or a covered element fail at once); `host >>> inner` selectors reach open shadow roots and same-origin iframes (also in `fill_input`, `scroll`, `wait_for`); a dialog or debugger pause the click causes is noted in a successful reply (`{dialog}` or `{paused, location}`) |
+| `fill_input` | ✓ | ✓ | picks `<select>` options; sets `date`, `time`, `datetime-local`, `month`, `week`, `range` and `color` inputs to the text in their own format (`2026-10-31`, `13:45`, `72`, `#ff0000`), firing `input` and `change`, noting a value the input adjusted (a range snaps to its step) and failing, without changing it, on a malformed one; fails without typing on elements that cannot take the text; `append: true` types after the content instead of replacing it (a number or email field, which has no caret, is retyped whole); an editor of its own (an element with an `EditContext` or a focusable `textbox` role, or the hidden input of a code editor such as Monaco or Ace) gets the keys a user presses: a click on the editor when its input has no visible box, Control+A (Command+A on macOS) or Control+End, then the text, and the reply says its content could not be checked; in a contenteditable element (including rich text editors such as Slate, Lexical, ProseMirror or CodeMirror 6) it selects the content (a range, then Control+A as a user would) and types over it, so the editor records the edit; types key by key on both (key handlers run; newlines and tabs inserted as text), about 1 ms per character; `change` on leaving the field, or at the end when the window has no focus |
 | `press_key` | ✓ | ✓ | one key (a character, Enter, Tab, Escape, arrows, F1–F12...) with Control / Shift / Alt / Meta held, in `selector` (focused first) or the focused element; a shortcut types nothing |
 | `hover` | ✓ | ✓ | moves the mouse over the element (scrolled into view; fails when hidden or covered) |
 | `drag` | ✓ | ✓ | presses on `from` (checked like `click_element`), moves in steps to the centre of `to` (which must then be in the viewport) and releases: sortable lists, boards, sliders; HTML5 drag and drop is real on Chrome and simulated with script events on Firefox (its WebDriver input starts a native drag but never drops it), and the reply says so |
 | `fill_form` | ✓ | ✓ | several fields in one call: text and `<select>` as `fill_input`, a checkbox or radio takes `true`/`false` and is clicked only when its state differs; stops at the first failing field naming what was done; never echoes values |
 | `upload_file` | ✓ | ✓ | `files` group; sets the files of an `<input type=file>` (Chrome `DOM.setFileInputFiles`, Firefox `input.setFiles`); files must be under the upload roots (`--upload-root`, default the working and temp directories) |
 | `handle_dialog` | ✓ | ✓ | accepts or dismisses the open `alert` / `confirm` / `prompt` / `beforeunload` dialog |
-| `evaluate_js` | ✓ | ✓ | `value` at most 100 000 characters (`truncated: true`); Chrome stops a script after 8 s, Firefox cannot (a looping tab is closed with `close_tab`) |
+| `evaluate_js` | ✓ | ✓ | `await` at the top level (`const r = await fetch(u); r.json()`), as in a console; `value` at most 100 000 characters (`truncated: true`); symbols and functions are described; Chrome stops a script after 8 s, Firefox cannot (a looping tab is closed with `close_tab`) |
 | `cookies` | ✓ | ✓ | `storage` group; `get` / `set` / `delete`: the cookies sent to the page (or `url`) or of a `domain`; values hidden unless `show_values: true` (Chrome `Network.*Cookie*`, Firefox BiDi `storage.*` in the tab's partition) |
 | `web_storage` | ✓ | ✓ | `storage` group; `get` / `set` / `delete` / `clear` on the page's `localStorage` or `sessionStorage`; values hidden unless `show_values: true` |
 | `get_console_logs` | ✓ | ✓ | one line per message, oldest first: `[level] text @ url:line` (lines from 1), objects and arrays previewed as the console shows them (`{n: 1}`, `[1, 2, 3]`), repeats in a row folded (`[x3]`), uncaught errors marked with up to 5 stack lines indented; `include_details: true` gives the JSON with every field; a message keeps at most 10 000 characters; Firefox: page errors, CSS warnings and platform messages need the debugger port |
@@ -154,7 +154,7 @@ see the note.
 | `resume` | ✓ | ✓ | |
 | `step_over` | ✓ | ✓ | |
 | `evaluate_on_call_frame` | ✓ | ✓ | |
-| `search_scripts` | ✓ | ✓ | a long line's preview is 100 characters on each side of the match |
+| `search_scripts` | ✓ | ✓ | a long line's preview is 100 characters on each side of the match; frames of another origin too (Chrome ids such as `2.17`) |
 | `pause_on_load` | ✓ | ✗ | TODO on Firefox, see [Limitations and TODO](#limitations-and-todo) |
 | `enable_proxy_auth` | ✓ | partial | needs `--proxy-server`; a request the proxy rejects twice is cancelled; untested on Firefox against a real proxy |
 | `send_cdp_command` | ✓ | ✗ | `raw` group; raw Chrome DevTools Protocol; refuses `Network`/`Page`/`Runtime`/`Log`/`Debugger.disable` and `Browser.close`; `Fetch.enable` comes with a note |
@@ -173,7 +173,9 @@ action nothing reacts to costs those 50 ms and keeps its reply; otherwise
 the reply adds `The page reacted (the DOM changed, 1 request(s)) and settled
 after 134 ms.`, or says the page was still changing after 1 s. A click that
 navigates waits for the new page's requests. Use `wait_for` for anything
-slower (a timer, a long request).
+slower (a timer, a long request). An action that opened tabs (a
+`target=_blank` link, `window.open`) says so: `The action opened tab tab-3
+(https://…): call switch_tab with its tab_id to act in it.`
 
 The JavaScript debugger tools on Firefox need its debugger (RDP) port: on by
 default for a launched Firefox, `--firefox-rdp-port` for an attached one. The
@@ -623,7 +625,11 @@ incompatible:
 - Frames of another origin: `evaluate_js` runs in the page only, and
   `capture_screenshot` cannot clip to an element inside such a frame (pass
   the iframe's ref instead); `snapshot` reads at most 20 of them, 5 deep;
-  the coordinates in the replies of the input tools are the frame's.
+  the coordinates in the replies of the input tools are the frame's. On
+  Chrome, the console and network of at most 50 of them per tab are
+  logged, and the debugger reaches their scripts (ids such as `2.17`:
+  frame 2's script 17), as it does on Firefox; `pause_on_load` pauses the
+  page only.
 
 ## Untested
 

package/npm-shrinkwrap.json

@@ -19,7 +19,7 @@
       "hasInstallScript": true,
       "license": "MIT",
       "name": "@raultov/browser-control-mcp",
-      "version": "0.8.0-beta.12"
+      "version": "0.10.0-beta.14"
     },
     "node_modules/detect-libc": {
       "engines": {
@@ -48,5 +48,5 @@
     }
   },
   "requires": true,
-  "version": "0.8.0-beta.12"
+  "version": "0.10.0-beta.14"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "artifactDownloadUrls": [
-    "https://github.com/raultov/browser-control-mcp/releases/download/v0.8.0-beta.12"
+    "https://github.com/raultov/browser-control-mcp/releases/download/v0.10.0-beta.14"
   ],
   "author": "raultov <raultov@protonmail.com>",
   "bin": {
@@ -92,7 +92,7 @@
       "zipExt": ".tar.xz"
     }
   },
-  "version": "0.8.0-beta.12",
+  "version": "0.10.0-beta.14",
   "volta": {
     "node": "18.14.1",
     "npm": "9.5.0"