@capagents/forgeqe 1.1.2 → 1.1.4

package/forgeqe.example.yaml

@@ -4,6 +4,10 @@ llm:
 
 browser:
   # provider: local          # local | browserstack | testmu
+  # providers:               # keep BrowserStack / TestMu AI details in separate YAML files
+  #   browserstack: ./.forgeqe/browserstack.yaml
+  #   testmu: ./.forgeqe/testmu.yaml
+  #                         # ForgeQE's agent can switch to one of these per request with browser_provider
   headless: true
   max_steps: 40 # a checkpoint: a run still making progress carries on, up to 3x
   timeout_seconds: 600 # whole run
@@ -15,8 +19,8 @@ browser:
   judge: false # true: a second model call checks each finished run against the goal and can fail it
   overlay: true # visible browser: ForgeQE start page, edge glow, a bar with the current step, your mouse and keyboard locked while the agent works
   # start_url: https://staging.example.com   # optional; omit to let the agent choose the site
-  # remote:                    # only when provider is browserstack or testmu
-  #   browser: playwright-chromium   # BrowserStack: playwright-chromium / playwright-firefox / playwright-webkit
+  # remote:                    # inline settings for the selected remote provider; override the provider file when both are set
+  #   browser: chrome   # BrowserStack: chrome or edge (ForgeQE drives the browser over CDP)
   #   browser_version: latest
   #   os: osx
   #   os_version: sequoia
@@ -109,13 +113,15 @@ report:
   screenshots: all            # all | failures | off: step screenshots in report.html
   accessibility: true         # check each page the agent visits (names, labels, image text, contrast, lang, zoom)
 
-# Offline BI with Evidence: ForgeQE exports CSV datasets and runs Evidence to build static HTML, no always-on server.
-# forgeqe bi init scaffolds the Evidence project, forgeqe bi sync refreshes the data, forgeqe bi build does both
-# and runs evidence build. The datasets below are optional: local ForgeQE suite/readiness data exports either way.
+# Offline BI with Evidence: ForgeQE exports CSV datasets and runs Evidence (@evidence-dev/evidence 40.x, needs Node.js)
+# to build a static site, no always-on server. forgeqe bi init scaffolds the Evidence project, forgeqe bi sync refreshes
+# the data, forgeqe bi build does both and builds the site; without Node.js, or with --static, it writes ForgeQE's own
+# page instead. The datasets below are optional: local ForgeQE suite/readiness data exports either way.
+# Dataset ids are table names (forgeqe.<id>): letters, digits, and _.
 # bi:
 #   title: ForgeQE BI
 #   # evidence_dir: ./evidence                    # the managed Evidence project
-#   # data_dir: ./evidence/sources/forgeqe/data  # CSV exports that the Evidence project reads
+#   # data_dir: ./evidence/sources/forgeqe       # CSV exports; copied there when set elsewhere
 #   # build_dir: ./.forgeqe/reports/bi           # static HTML output from evidence build
 #   datasets:
 #     ado_current_sprint:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capagents/forgeqe",
-  "version": "1.1.2",
-  "description": "ForgeQE: a browser agent CLI that runs goals and test cases in Chrome and turns passing runs into tests in your repo",
+  "version": "1.1.4",
+  "description": "ForgeQE: a browser agent CLI that runs goals and test cases in local Chrome or Chromium, or BrowserStack and TestMu AI/LambdaTest when configured, and turns passing runs into tests in your repo",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -20,7 +20,9 @@
     "README.md",
     "HOW_TO_USE.md",
     "forgeqe-architecture.html",
+    "browserstack.example.yaml",
     "forgeqe.example.yaml",
+    "testmu.example.yaml",
     "llms.example.json"
   ],
   "engines": {

package/py/forgeqe_engine/browser.py

@@ -3,11 +3,11 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import json
 import logging
 import os
 import time
-from importlib.metadata import version as package_version
 from pathlib import Path
 from typing import Any, Dict, Optional
 from urllib.parse import quote, urlparse
@@ -140,13 +140,6 @@ def _remote_secret(name: str, provider: str, label: str) -> str:
     raise RuntimeError(f'{provider}: set {name} ({label}) in the environment, or save it with "forgeqe auth login {provider}".')
 
 
-def _playwright_version() -> Optional[str]:
-    try:
-        return package_version("playwright")
-    except Exception:
-        return None
-
-
 def _browserstack_caps(remote: Dict[str, Any]) -> Dict[str, Any]:
     caps: Dict[str, Any] = {
         "browser": str(remote.get("browser") or ""),
@@ -164,9 +157,6 @@ def _browserstack_caps(remote: Dict[str, Any]) -> Dict[str, Any]:
         caps["name"] = str(remote["name"])
     if remote.get("local") is True:
         caps["browserstack.local"] = True
-    pw = _playwright_version()
-    if pw:
-        caps["client.playwrightVersion"] = pw
     extra = remote.get("extra")
     if isinstance(extra, dict):
         caps.update(extra)
@@ -229,6 +219,83 @@ def browser_connection_label(provider: str, launch: Dict[str, Any], remote: Opti
     return " · ".join(x for x in [provider, browser, target] if x)
 
 
+_PAGE_PASSWORD_JS = """(() => ({
+  url: location.href,
+  filled: Array.from(document.querySelectorAll('input[type=password]')).some((e) => (e.value || '').length > 0),
+}))()"""
+
+
+def typed_into_password(history_item: Any) -> bool:
+    """Whether a step typed into a password field: its actions line up with the elements they touched."""
+    actions = getattr(getattr(history_item, "model_output", None), "action", None) or []
+    elements = getattr(getattr(history_item, "state", None), "interacted_element", None) or []
+    for action, element in zip(actions, elements):
+        attributes = (getattr(element, "attributes", None) or {}) if element is not None else {}
+        if str(attributes.get("type") or "").lower() != "password":
+            continue
+        try:
+            name = next(iter(action.model_dump(exclude_unset=True)), "")
+        except Exception:
+            name = ""
+        if any(word in name for word in ("input", "type", "fill")):
+            return True
+    return False
+
+
+class FreshTabAfterPassword:
+    """
+    Remote grids only: after a password form is submitted, TestMu AI's Chrome stops taking real mouse and keyboard
+    input on that tab (most likely its password manager's bubble), while the page itself still works: clicks report
+    success and change nothing. The same URL in a fresh tab takes input again, with the session's cookies intact.
+    Armed when a step types into a password field (or one is filled when a step ends); fires once the page has left
+    that URL with no filled password field, so a failed sign-in that stays on the form does not move tabs.
+    """
+
+    def __init__(self) -> None:
+        self.armed_at: Optional[str] = None
+
+    async def after_step(self, browser: Any, history_item: Any) -> Optional[str]:
+        """Returns the URL reopened in a fresh tab, or None."""
+        if typed_into_password(history_item):
+            self.armed_at = str(getattr(getattr(history_item, "state", None), "url", "") or "")
+        try:
+            session = await asyncio.wait_for(browser.get_or_create_cdp_session(), timeout=2)
+            r = await asyncio.wait_for(
+                session.cdp_client.send.Runtime.evaluate(
+                    params={"expression": _PAGE_PASSWORD_JS, "returnByValue": True}, session_id=session.session_id
+                ),
+                timeout=2,
+            )
+            state = ((r or {}).get("result") or {}).get("value") or {}
+        except Exception:
+            return None
+        url = str(state.get("url") or "")
+        if self.armed_at is None:
+            if state.get("filled"):
+                self.armed_at = url
+            return None
+        if not url.startswith("http") or url == self.armed_at or state.get("filled"):
+            return None
+        self.armed_at = None
+        await reopen_in_fresh_tab(browser, url)
+        return url
+
+
+async def reopen_in_fresh_tab(browser: Any, url: str) -> None:
+    """Open url in a new tab, which the agent then works in, and close the tab it was on."""
+    from browser_use.browser.events import CloseTabEvent, NavigateToUrlEvent
+
+    old = getattr(browser, "agent_focus_target_id", None)
+    event = browser.event_bus.dispatch(NavigateToUrlEvent(url=url, new_tab=True))
+    await event
+    await event.event_result(raise_if_any=True, raise_if_none=False)
+    if old and old != getattr(browser, "agent_focus_target_id", None):
+        with contextlib.suppress(Exception):
+            close = browser.event_bus.dispatch(CloseTabEvent(target_id=old))
+            await close
+            await close.event_result(raise_if_any=False, raise_if_none=False)
+
+
 async def _shutdown_browser_instance(browser: Any) -> None:
     """Stop the library gracefully, falling back to kill()."""
     if browser is None:

package/py/forgeqe_engine/service.py

@@ -44,8 +44,10 @@ from .llm import (
     _agent_usage,
 )
 from .browser import (
+    FreshTabAfterPassword,
     browser_connection_label,
     browser_launch_kwargs,
+    local_browser_launch_kwargs,
     settle_page,
     _shutdown_browser_instance,
     _stop_agent_instance,
@@ -1104,6 +1106,14 @@ async def run_browser_task(req: RunRequest, emit: Emit, cancel_event: asyncio.Ev
                 last = agent_ref.history.history[-1]
             except Exception:
                 return
+            if fresh_tab is not None:
+                try:
+                    reopened = await fresh_tab.after_step(browser, last)
+                except Exception as ex:
+                    reopened = None
+                    logger.warning("could not reopen the page in a fresh tab after sign-in: %s", ex)
+                if reopened:
+                    emit({"type": "log", "level": "info", "text": f"Signed in on {browser_provider}: reopened {reopened} in a fresh tab, so the page takes input again"})
             results = getattr(last, "result", None) or []
             if mem is not None:
                 mem.llm_steps = len(agent_steps(agent_ref.history.history))
@@ -1152,6 +1162,9 @@ async def run_browser_task(req: RunRequest, emit: Emit, cancel_event: asyncio.Ev
             if overlay is not None:
                 await overlay.thinking()
 
+        # Remote grids stop taking input on a tab after a password form is submitted: see FreshTabAfterPassword.
+        fresh_tab = FreshTabAfterPassword() if browser_provider != "local" else None
+
         async def _on_step_start(agent_ref: Any) -> None:
             if not collected_steps:
                 await diag.start(browser)

package/src/auth/signin.ts

@@ -58,8 +58,8 @@ export function envNames(cfg?: AppConfig) {
     zephyr: { url: "ZEPHYR_URL", token: s?.zephyr?.tokenEnv || "ZEPHYR_API_TOKEN" },
     qtest: { url: "QTEST_URL", project: "QTEST_PROJECT_ID", token: s?.qtest?.tokenEnv || "QTEST_TOKEN" },
     xray: { url: "XRAY_URL", id: s?.xray.clientIdEnv || "XRAY_CLIENT_ID", secret: s?.xray.clientSecretEnv || "XRAY_CLIENT_SECRET" },
-    browserstack: { user: b?.remote?.provider === "browserstack" ? b.remote.usernameEnv : "BROWSERSTACK_USERNAME", key: b?.remote?.provider === "browserstack" ? b.remote.accessKeyEnv : "BROWSERSTACK_ACCESS_KEY" },
-    testmu: { user: b?.remote?.provider === "testmu" ? b.remote.usernameEnv : "LT_USERNAME", key: b?.remote?.provider === "testmu" ? b.remote.accessKeyEnv : "LT_ACCESS_KEY" },
+    browserstack: { user: b?.remotes?.browserstack?.usernameEnv || "BROWSERSTACK_USERNAME", key: b?.remotes?.browserstack?.accessKeyEnv || "BROWSERSTACK_ACCESS_KEY" },
+    testmu: { user: b?.remotes?.testmu?.usernameEnv || "LT_USERNAME", key: b?.remotes?.testmu?.accessKeyEnv || "LT_ACCESS_KEY" },
   }
 }