ai-dev-browser 0.58.0__tar.gz → 0.58.2__tar.gz

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/.github/workflows/ci.yml

@@ -31,6 +31,9 @@ jobs:
       - name: Install package
         run: uv sync --extra dev --extra remote
 
+      - name: Check extension window and ownership contracts
+        run: node --test tests/unit/extension_ownership.test.cjs
+
       # ── Tool dispatch smoke test ──
       # Verifies python -m entry point works on all platforms.
       - name: Test tool dispatch
@@ -158,19 +161,19 @@ jobs:
       - run: python -m pip install ".[dev,remote]"
       - name: Install the real X11 and noVNC viewer
         if: runner.os == 'Linux'
-        run: sudo apt-get update -qq && sudo apt-get install -y xvfb xauth x11vnc novnc websockify
+        run: sudo apt-get update -qq && sudo apt-get install -y xvfb xauth x11vnc novnc websockify openbox xdotool xclip
       - name: Run page, extension and full-window workflows on Linux
         if: runner.os == 'Linux'
         env:
           AI_DEV_BROWSER_CHROME: ${{ steps.chrome.outputs.chrome-path }}
           AI_DEV_BROWSER_TEST_EXTENSION_CHROME: ${{ steps.chrome.outputs.chrome-path }}
-        run: xvfb-run -a -s "-screen 0 1280x1000x24" python -m pytest -v --full-trace -o faulthandler_timeout=180 tests/integration/test_remote_view.py tests/integration/test_remote_vnc.py tests/integration/test_browser_control_live.py tests/integration/test_browser_session_live.py tests/integration/test_browser_files_live.py tests/integration/test_browser_worker_live.py tests/integration/test_existing_worker_live.py tests/integration/test_navigation_startup.py --basetemp remote-results
+        run: xvfb-run -a -s "-screen 0 1280x1000x24" python -m pytest -v --full-trace -o faulthandler_timeout=180 tests/integration/test_remote_view.py tests/integration/test_remote_selection_live.py tests/integration/test_remote_vnc.py tests/integration/test_browser_control_live.py tests/integration/test_browser_session_live.py tests/integration/test_browser_files_live.py tests/integration/test_browser_worker_live.py tests/integration/test_existing_worker_live.py tests/integration/test_navigation_startup.py --basetemp remote-results
       - name: Run page and extension workflows on Windows
         if: runner.os == 'Windows'
         env:
           AI_DEV_BROWSER_CHROME: ${{ steps.chrome.outputs.chrome-path }}
           AI_DEV_BROWSER_TEST_EXTENSION_CHROME: ${{ steps.chrome.outputs.chrome-path }}
-        run: python -m pytest -v --full-trace -o faulthandler_timeout=180 tests/integration/test_remote_view.py tests/integration/test_browser_control_live.py tests/integration/test_browser_session_live.py tests/integration/test_browser_files_live.py tests/integration/test_browser_worker_live.py tests/integration/test_existing_worker_live.py tests/integration/test_navigation_startup.py --basetemp remote-results
+        run: python -m pytest -v --full-trace -o faulthandler_timeout=180 tests/integration/test_remote_view.py tests/integration/test_remote_selection_live.py tests/integration/test_browser_control_live.py tests/integration/test_browser_session_live.py tests/integration/test_browser_files_live.py tests/integration/test_browser_worker_live.py tests/integration/test_existing_worker_live.py tests/integration/test_navigation_startup.py --basetemp remote-results
       - name: Retain real viewer evidence
         if: always()
         uses: actions/upload-artifact@v4
@@ -249,6 +252,21 @@ jobs:
           AI_DEV_BROWSER_TEST_EXTENSION_CHROME: ${{ steps.chrome.outputs.chrome-path }}
         run: uv run --no-sync python -m pytest -v --full-trace -o faulthandler_timeout=180 tests/integration/test_cli_extension_workflows.py tests/integration/test_recording_workflows.py tests/integration/test_recording_demo.py tests/integration/test_browser_lifecycle.py tests/integration/test_remote_view.py tests/integration/test_extension_ownership.py tests/integration/test_cli_steering.py -k "real_extension or outbound_proxy" --basetemp extension-results
 
+      - name: Install the unchanged released extension fixture
+        run: uv pip install --target previous-extension-fixture --no-deps ai-dev-browser==0.57.7
+
+      - name: Verify live upgrade diagnostics against the released extension
+        env:
+          AI_DEV_BROWSER_TEST_EXTENSION_CHROME: ${{ steps.chrome.outputs.chrome-path }}
+          AI_DEV_BROWSER_TEST_PREVIOUS_EXTENSION: ${{ github.workspace }}/previous-extension-fixture/ai_dev_browser/extension
+        run: uv run --no-sync python -m pytest -v tests/integration/test_extension_window_previous.py --basetemp previous-extension-results
+
+      - name: Honor genuine Windows window visibility before input
+        if: runner.os == 'Windows'
+        env:
+          AI_DEV_BROWSER_TEST_EXTENSION_CHROME: ${{ steps.chrome.outputs.chrome-path }}
+        run: uv run --no-sync python -m pytest -v tests/integration/test_extension_window_native.py --basetemp native-window-results
+
       - name: Install native Chrome interaction tools
         if: runner.os == 'Linux'
         run: sudo apt-get update -qq && sudo apt-get install -y xvfb xauth openbox xdotool
@@ -285,6 +303,10 @@ jobs:
             extension-results/**/extension-chrome.log
             extension-results/**/extension-cleanup-stacks.txt
             native-ownership-results/**
+            native-window-results/**/native-window-evidence.json
+            native-window-results/**/native-window-accepted.png
+            native-window-results/**/extension-chrome.log
+            previous-extension-results/**/previous-extension-evidence.json
 
   # ─────────────────────────────────────────────────────────────────────
   # CI-integration dogfood: prove the documented "consumer's CI" recipe

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-dev-browser
-Version: 0.58.0
+Version: 0.58.2
 Summary: A browser for AI to develop web automation — human-like automation that works seamlessly in a world designed for humans
 Author: sudoprivacy
 License: AGPL-3.0
@@ -454,6 +454,16 @@ Each GitHub release includes the same wheel and source distribution sent to PyPI
 the bundled Chrome extension as an unpackable ZIP, and `SHA256SUMS`.
 For extension mode, extract the ZIP and load its directory in `chrome://extensions`.
 After upgrading, reload the extension and restart an already running bridge.
+`browser_connect` reports the actual loaded `extension_version`, the
+`bundled_extension_version`, and whether they match. Updating Python alone does
+not reload Chrome's extension. Reload can reset control; inspect the session and
+its owned page before resuming input.
+
+For a hidden extension page, `window_set --state normal --focus` requests real
+window restoration and reports observed `visibility`, `focused`, and
+`input_ready`. A focused window may still be occluded. Keep it genuinely visible
+before input; focus emulation does not resolve a hidden-page refusal. See the
+[live window investigation](docs/BR-real-profile-hidden-input-resolution.md).
 
 Maintainers: run live browser acceptance and wait for CI on the release commit.
 Create an annotated `vX.Y.Z` tag with `git tag -a --cleanup=verbatim` and use the

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/README.md

@@ -412,6 +412,16 @@ Each GitHub release includes the same wheel and source distribution sent to PyPI
 the bundled Chrome extension as an unpackable ZIP, and `SHA256SUMS`.
 For extension mode, extract the ZIP and load its directory in `chrome://extensions`.
 After upgrading, reload the extension and restart an already running bridge.
+`browser_connect` reports the actual loaded `extension_version`, the
+`bundled_extension_version`, and whether they match. Updating Python alone does
+not reload Chrome's extension. Reload can reset control; inspect the session and
+its owned page before resuming input.
+
+For a hidden extension page, `window_set --state normal --focus` requests real
+window restoration and reports observed `visibility`, `focused`, and
+`input_ready`. A focused window may still be occluded. Keep it genuinely visible
+before input; focus emulation does not resolve a hidden-page refusal. See the
+[live window investigation](docs/BR-real-profile-hidden-input-resolution.md).
 
 Maintainers: run live browser acceptance and wait for CI on the release commit.
 Create an annotated `vX.Y.Z` tag with `git tag -a --cleanup=verbatim` and use the

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/_extension_lifecycle.py

@@ -66,6 +66,7 @@ async def start(
     url,
     startup_timeout,
     extra_args,
+    display=None,
 ) -> dict:
     if not user_data_dir:
         return _session.failure(
@@ -105,7 +106,9 @@ async def start(
     if (
         not headless
         and sys.platform.startswith("linux")
-        and not (os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))
+        and not (
+            display or os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")
+        )
     ):
         return _session.failure(
             "unsupported",
@@ -174,7 +177,11 @@ async def start(
     command += arguments + [
         f"http://127.0.0.1:{EXTENSION_BRIDGE_PORT}/adb-launch/{token}"
     ]
-    process = _spawn_chrome(command, silent_stderr=True)
+    process = _spawn_chrome(
+        command,
+        silent_stderr=True,
+        **({"display": display} if display is not None else {}),
+    )
     observed = _session.process_info(process.pid)
     record = {
         "transport": "extension",
@@ -193,6 +200,7 @@ async def start(
             "headless": headless,
             "startup_timeout": startup_timeout,
             "extra_args": arguments,
+            "display": display,
         },
     }
     if observed:

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/_session.py

@@ -211,24 +211,38 @@ def capabilities(record: dict) -> dict:
 
 
 def describe(record: dict) -> dict:
-    return {
-        key: record.get(key)
-        for key in (
-            "session_id",
-            "transport",
-            "owner",
-            "profile_owner",
-            "pid",
-            "port",
-            "chrome_path",
-            "user_data_dir",
-            "profile_directory",
-            "profile_id",
-            "headless",
-            "browser_version",
-            "automation_target_id",
-        )
-    } | {
-        "launch_chrome_path": (record.get("start_options") or {}).get("chrome_path"),
-        "capabilities": capabilities(record),
-    }
+    return (
+        {
+            key: record.get(key)
+            for key in (
+                "session_id",
+                "transport",
+                "owner",
+                "profile_owner",
+                "pid",
+                "port",
+                "chrome_path",
+                "user_data_dir",
+                "profile_directory",
+                "profile_id",
+                "headless",
+                "browser_version",
+                "automation_target_id",
+            )
+        }
+        | {
+            "launch_chrome_path": (record.get("start_options") or {}).get(
+                "chrome_path"
+            ),
+            "capabilities": capabilities(record),
+        }
+        | {
+            key: record.get(key)
+            for key in (
+                "extension_version",
+                "bundled_extension_version",
+                "extension_version_matches_bundle",
+            )
+            if record.get("transport") == "extension"
+        }
+    )

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/_tab.py

@@ -918,7 +918,25 @@ class Tab:
     async def _set_window_state(self, state: str):
         window_id, _ = await self.get_window()
         bounds = cdp_browser.Bounds(window_state=cdp_browser.WindowState(state))
-        await self.send(cdp_browser.set_window_bounds(window_id, bounds))
+        try:
+            await self.send(cdp_browser.set_window_bounds(window_id, bounds))
+        except ProtocolException as error:
+            if getattr(
+                self._browser, "transport", "cdp"
+            ) != "extension" or not _is_cdp_method_not_found(error):
+                raise
+            from .errors import InputUnavailableError
+
+            observed_state: dict = {"visibility": "unknown", "focused": None}
+            try:
+                observed_state = await self._input_state(timeout=1)
+            except Exception:
+                pass  # A diagnostic read must not replace the unsupported-route error.
+            raise InputUnavailableError(
+                "The loaded extension does not support Browser.setWindowBounds; "
+                "the requested window state was not applied and no input was sent",
+                details=await self._input_diagnostics(observed_state),
+            ) from error
 
     async def maximize(self):
         await self._set_window_state("maximized")
@@ -941,6 +959,45 @@ class Tab:
         """Alias for activate()."""
         await self.activate()
 
+    async def _input_state(self, *, timeout: float | None = None) -> dict:
+        """Read genuine page visibility and document focus independently."""
+        return await self.evaluate(
+            "({visibility:document.visibilityState,focused:document.hasFocus()})",
+            timeout=timeout,
+        )
+
+    async def _wait_input_visibility(self) -> dict:
+        deadline = time.monotonic() + 2
+        state = await self._input_state()
+        while state["visibility"] != "visible" and time.monotonic() < deadline:
+            await asyncio.sleep(0.05)
+            state = await self._input_state()
+        return state
+
+    async def _input_diagnostics(self, state: dict) -> dict:
+        """Bounded, read-only support data; never include flow URLs or accounts."""
+        from .extension import extension_version_info, query_extension_version
+
+        details = {
+            "input_sent": False,
+            "input_scope": "current_dispatch",
+            "target_id": str(self._target.target_id),
+            **state,
+        }
+        if getattr(self._browser, "transport", "cdp") != "extension":
+            return details
+        loaded = await query_extension_version(self._browser)
+        details.update(extension_version_info(loaded))
+        try:
+            window_id, bounds = await self.send(
+                cdp_browser.get_window_for_target(self._target.target_id), timeout=1
+            )
+            details["window_state"] = bounds.window_state.value
+            details["window_id"] = window_id
+        except Exception:
+            pass  # Preserve the original refusal if diagnostic support is incomplete.
+        return details
+
     async def _prepare_input(self, allow_cached: bool = False):
         """Wake only the selected extension page before trusted input."""
         if getattr(self._browser, "transport", "cdp") != "extension":
@@ -950,26 +1007,23 @@ class Tab:
             and time.monotonic() - getattr(self, "_input_checked_at", 0) < 0.5
         ):
             return
-        visible = await self.evaluate("document.visibilityState === 'visible'")
-        if not visible:
+        state = await self._input_state()
+        if state["visibility"] != "visible":
             await self.bring_to_front()
-            deadline = time.monotonic() + 2
-            while time.monotonic() < deadline:
-                if await self.evaluate("document.visibilityState === 'visible'"):
-                    # Let the restored renderer paint before its first pointer event.
-                    await self.evaluate(
-                        "new Promise(resolve => requestAnimationFrame(() => resolve(true)))",
-                        await_promise=True,
-                        timeout=2,
-                    )
-                    break
-                await asyncio.sleep(0.05)
-            else:
+            state = await self._wait_input_visibility()
+            if state["visibility"] != "visible":
                 from .errors import InputUnavailableError
 
                 raise InputUnavailableError(
-                    "The automation page is still hidden after activation; this input was not sent. Show its Chrome window, then inspect page state before retrying"
+                    "The automation page is still hidden after activation; this input was not sent. Show its Chrome window, then inspect page state before retrying",
+                    details=await self._input_diagnostics(state),
                 )
+            # Let the restored renderer paint before its first pointer event.
+            await self.evaluate(
+                "new Promise(resolve => requestAnimationFrame(() => resolve(true)))",
+                await_promise=True,
+                timeout=2,
+            )
         self._input_checked_at = time.monotonic()
 
     async def close(self):

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/ax.py

@@ -871,10 +871,14 @@ async def _type_keystrokes(tab: Tab, text: str) -> None:
 async def _focus_el(element: Element) -> None:
     try:
         await element.focus()  # CDP DOM.focus
+    except SessionError:
+        raise
     except Exception:
         pass
     try:
         await element.apply("(el) => { if (el && el.focus) el.focus(); }")
+    except SessionError:
+        raise
     except Exception:
         pass
 
@@ -883,10 +887,12 @@ async def _clear_el(tab: Tab, element: Element) -> None:
     try:
         await element.apply(
             "(el) => { if (!el) return; if (el.focus) el.focus();"
-            " if ('value' in el) { el.value = '';"
+            " if ('value' in el && el.value !== '') { el.value = '';"
             " el.dispatchEvent(new Event('input', {bubbles: true})); }"
             " else if (el.isContentEditable) { el.textContent = ''; } }"
         )
+    except SessionError:
+        raise
     except Exception:
         pass
 
@@ -908,6 +914,8 @@ async def _field_state(element: Element, text: str) -> dict:
             if isinstance(st, dict)
             else {"matches": False, "empty": True, "length": 0}
         )
+    except SessionError:
+        raise
     except Exception:
         return {"matches": False, "empty": True, "length": 0}
 
@@ -948,6 +956,11 @@ async def _fill_verified(
     tried: list[str] = []
     st: dict | None = None
     for i, method in enumerate(order):
+        prepare_input = getattr(tab, "_prepare_input", None)
+        if prepare_input:
+            # This precedes even clearing/focusing: a hidden-page or ownership
+            # refusal must not turn into a value setter on a later rung.
+            await prepare_input()
         await _clear_el(tab, element)
         await _focus_el(element)
         tried.append(method)
@@ -960,6 +973,8 @@ async def _fill_verified(
                 await human.type_text(tab, text, element, humanize=True)
             elif method == "native":
                 await _native_set(element, text)
+        except SessionError:
+            raise
         except Exception:
             continue
         st = await _field_state(element, text)
@@ -994,6 +1009,9 @@ async def type_by_ref(
     (plus `entered` when `enter=True`) — `verified` already tells you the value
     actually landed, so don't screenshot or re-read the field to check.
 
+    In extension mode, hidden-page or ownership refusals stop the operation
+    before clearing; input fallbacks never override these refusals.
+
     If you can identify the input by its visible label / placeholder, skip
     `page_discover` and use `type_by_text` directly.
 

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/browser.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import os
+import re
 import time
 from pathlib import Path
 
@@ -23,6 +24,8 @@ from .extension import (
     EXTENSION_BRIDGE_PORT,
     extension_dir,
     extension_load_instructions,
+    extension_version_info,
+    query_extension_version,
 )
 from .port import (
     _cleanup_temp_profile,
@@ -202,6 +205,7 @@ def browser_start(
     chrome_path: str | None = None,
     user_data_dir: str | None = None,
     profile_directory: str = "Default",
+    display: str | None = None,
 ) -> dict:
     """Use when: you need a new isolated CDP session or explicitly launch a configured extension profile; returns session_id and actual capabilities.
 
@@ -236,6 +240,9 @@ def browser_start(
         transport: "cdp" (isolated automation, default) or "extension"
             (explicitly launch an already configured real Chrome/profile).
         chrome_path: Chrome executable to launch; otherwise find_chrome resolves it.
+        display: Optional local X11 display ID, such as ":2", for a host-owned
+            GUI. Passed only to this Chrome child; the calling process keeps
+            its DISPLAY unchanged. Omit to use the existing desktop display.
         user_data_dir: Existing Chrome user-data root, required for extension
             startup. CDP uses temp/named adb profiles; this option is extension only.
         profile_directory: Chrome folder inside user_data_dir, e.g. "Default"
@@ -341,6 +348,14 @@ def browser_start(
         replay input implicitly after failure.
     """
     start_options = dict(locals())
+    if display is not None and (
+        not isinstance(display, str) or not re.fullmatch(r":\d+(?:\.\d+)?", display)
+    ):
+        return _session.failure(
+            "validation",
+            "An explicit display must be a local X11 display ID",
+            transport=transport,
+        )
     startup_timeout = resolve_startup_timeout(startup_timeout)
     if transport == "extension":
         if (
@@ -369,6 +384,7 @@ def browser_start(
                 url=url,
                 startup_timeout=startup_timeout,
                 extra_args=extra_args,
+                display=display,
             )
         )
     if (
@@ -386,7 +402,7 @@ def browser_start(
         import sys
 
         if sys.platform.startswith("linux") and not (
-            os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")
+            display or os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")
         ):
             return _session.failure(
                 "unsupported",
@@ -490,6 +506,8 @@ def browser_start(
     from typing import Any
 
     launch_options: dict[str, Any] = {"chrome_path": chrome_path} if chrome_path else {}
+    if display is not None:
+        launch_options["display"] = display
     for attempt in range(max_attempts):
         process = launch_chrome(
             port=port,
@@ -791,6 +809,10 @@ async def browser_connect(
     tab_switch/tab_close; automation_target_id tracks the main page identity.
     For visible local collaboration, show the dedicated page with tab_switch
     using its targets index so the human and agent work on that same page.
+    Extension results report the loaded `extension_version` separately from
+    `bundled_extension_version`; an unknown version stays null. Updating Python
+    does not reload Chrome's extension. Ordinary extension reload can reset
+    control: inspect the session and original owned page before further input.
 
     Args:
         transport: "cdp" (default, existing debug Chrome) or "extension"
@@ -806,7 +828,8 @@ async def browser_connect(
     Returns:
         dict with connected, transport, session_id, capabilities, profile_id,
         owner, profile_owner, actual headless (null if unknown), account for
-        extension, port for CDP, tabs and tab_count. Includes version/git_commit.
+        extension, port for CDP, tabs and tab_count. Includes version/git_commit
+        and loaded/bundled extension versions with their observed match status.
 
     Failure:
         Read error_code and setup_instructions. Missing bridge/extension needs
@@ -933,6 +956,9 @@ async def browser_connect(
                 {"tab_id": str(t._target.target_id), "url": t._target.url or ""}
                 for t in browser.tabs
             ]
+            loaded_version = await query_extension_version(
+                browser, status.get("extension_version")
+            )
         finally:
             await browser.close()
         main = status.get("automation_target_id")
@@ -951,6 +977,7 @@ async def browser_connect(
                 "profile_id": status["profile_id"],
                 "automation_target_id": main,
                 "browser_version": status.get("browser_version"),
+                **extension_version_info(loaded_version),
             }
         )
         _session.write(record)

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/chrome.py

@@ -17,6 +17,7 @@ import shutil
 import subprocess
 import tempfile
 from pathlib import Path
+from typing import Any
 
 from .config import DEFAULT_DEBUG_PORT, DEFAULT_PROFILE_PREFIX, resolve_viewport
 
@@ -155,6 +156,7 @@ def launch_chrome(
     hide_crash_restore_bubble: bool = True,
     stealth: bool = True,
     chrome_path: str | None = None,
+    display: str | None = None,
 ) -> subprocess.Popen:
     """
     Launch Chrome with remote debugging enabled.
@@ -338,10 +340,14 @@ def launch_chrome(
     if start_url:
         args.append(start_url)
 
+    if display is not None:
+        return _spawn_chrome(args, silent_stderr=silent_stderr, display=display)
     return _spawn_chrome(args, silent_stderr=silent_stderr)
 
 
-def _spawn_chrome(args: list[str], silent_stderr: bool = False) -> subprocess.Popen:
+def _spawn_chrome(
+    args: list[str], silent_stderr: bool = False, *, display: str | None = None
+) -> subprocess.Popen:
     """Shared detached process primitive for CDP and configured-profile startup."""
     # Start Chrome process
     try:
@@ -349,6 +355,7 @@ def _spawn_chrome(args: list[str], silent_stderr: bool = False) -> subprocess.Po
         # On Unix, use start_new_session to detach from parent
         # On Windows, CREATE_NEW_PROCESS_GROUP for similar isolation
         stderr_target = subprocess.DEVNULL if silent_stderr else subprocess.PIPE
+        popen_kwargs: dict[str, Any]
         if platform.system() == "Windows":
             popen_kwargs = {
                 "stdout": subprocess.DEVNULL,
@@ -362,6 +369,8 @@ def _spawn_chrome(args: list[str], silent_stderr: bool = False) -> subprocess.Po
                 "start_new_session": True,
             }
 
+        if display is not None:
+            popen_kwargs["env"] = {**os.environ, "DISPLAY": display}
         logger.debug("Launching Chrome executable %s", args[0])
         process = subprocess.Popen(args, **popen_kwargs)  # type: ignore[call-overload]
 

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/elements.py

@@ -1239,6 +1239,9 @@ async def type_by_text(
     `{typed, verified, method, name}` (plus `entered` when `enter=True`) —
     `verified` already confirms the value landed, so don't re-read to check.
 
+    In extension mode, hidden-page or ownership refusals stop the operation
+    before clearing; input fallbacks never override these refusals.
+
     Prefer over `type_by_ref` when you can identify the input by its
     human-visible label rather than needing a prior `page_discover` ref. The
     `clear` / `enter` / `keystrokes` / `human_like` options mirror `type_by_ref`

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/errors.py

@@ -27,8 +27,19 @@ class SessionError(Exception):
 class InputUnavailableError(SessionError):
     """A requested input was withheld because its page could not be made visible."""
 
-    def __init__(self, message: str):
+    def __init__(self, message: str, *, details: dict | None = None):
         super().__init__(message, error_code="unsupported")
+        self.details = details or {}
+        self.hint = (
+            "This input dispatch was not sent. Show the selected Chrome tab/window "
+            "and inspect current state before resuming; earlier steps may have "
+            "completed. If the loaded "
+            "extension version is unknown or differs from the bundle, arrange an "
+            "ordinary update/reload in chrome://extensions; reloading can reset "
+            "control, so inspect session ownership again afterwards. Do not replay "
+            "earlier submissions, spoof visibility/focus, switch transport or use "
+            "OS input to bypass the refusal."
+        )
 
 
 class RecordingError(Exception):

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/ext_bridge.py

@@ -180,7 +180,7 @@ class _Bridge:
     # ------------------------------------------------------------------ drivers
     _LOGGED = (
         "Page.navigate",
-        "Input.dispatch",
+        "Input.",  # Command names only: never include typed text in the log.
         "Runtime.evaluate",
         "Runtime.callFunctionOn",
     )

{ai_dev_browser-0.58.0 → ai_dev_browser-0.58.2}/ai_dev_browser/core/extension.py

@@ -10,6 +10,7 @@ package ships and the steps to relay to the user.
 from __future__ import annotations
 
 from pathlib import Path
+import json
 import os
 
 # Fixed local port the extension's background.js dials and the adb-side bridge
@@ -26,6 +27,34 @@ def extension_dir() -> Path:
     return Path(__file__).resolve().parent.parent / "extension"
 
 
+def extension_version_info(loaded_version: str | None) -> dict:
+    """Compare a running extension's report with the bundled manifest, not Python."""
+    bundled = json.loads(
+        (extension_dir() / "manifest.json").read_text(encoding="utf-8")
+    )["version"]
+    return {
+        "extension_version": loaded_version,
+        "bundled_extension_version": bundled,
+        "extension_version_matches_bundle": loaded_version == bundled
+        if loaded_version
+        else None,
+    }
+
+
+async def query_extension_version(browser, fallback: str | None = None) -> str | None:
+    """Read the live extension, including when an older bridge drops hello fields."""
+    from .cdp import _get_cdp_command
+
+    try:
+        state = await browser.connection.send(
+            _get_cdp_command("AiDevBrowser.debugState", {}), timeout=1
+        )
+        version = state.get("extensionVersion")
+        return version if isinstance(version, str) else fallback
+    except Exception:
+        return fallback  # Diagnostics never replace the actual operation's error.
+
+
 def extension_load_instructions(extension_dir_path: str | None = None) -> str:
     """Step-by-step 'Load unpacked' guidance, with the resolved package path.