@capagents/forgeqe 1.1.3 → 1.1.4

package/README.md

@@ -1,6 +1,6 @@
 # ForgeQE
 
-Browser agent CLI. Say what you want in plain language: a goal to carry out in a browser, test cases to run from Jira, Azure DevOps, Xray or a file, a test to write, or a CI pipeline to set up. ForgeQE's agent works out what that needs and calls ForgeQE's tools. The ForgeQE engine drives Chrome locally, or BrowserStack and TestMu AI/LambdaTest through their Playwright CDP endpoints, and a run that passes becomes a test in your repo's own language and framework, written by **Scribe**, ForgeQE's coding agent. Skills (`SKILL.md` folders, built in or in `.forgeqe/skills`) teach the agents your repo's conventions and the apps you test.
+Browser agent CLI. Say what you want in plain language: a goal to carry out in a browser, test cases to run from Jira, Azure DevOps, Xray or a file, a test to write, or a CI pipeline to set up. ForgeQE's agent works out what that needs and calls ForgeQE's tools. The ForgeQE engine drives Chrome locally, or BrowserStack and TestMu AI/LambdaTest through their Chrome DevTools Protocol (CDP) endpoints, and a run that passes becomes a test in your repo's own language and framework, written by **Scribe**, ForgeQE's coding agent. Skills (`SKILL.md` folders, built in or in `.forgeqe/skills`) teach the agents your repo's conventions and the apps you test.
 
 The engine is the browser service from test-agent-nexus, copied into this package (`py/forgeqe_engine`). It keeps the nexus behaviour: error-recovery system prompt, fast-mode agent tuning, Chrome launch flags, the search/select loop breaker, the 600 s run timeout, compact workflow YAML with semantic locators. There is no dependency on test-agent-nexus, FastAPI, or a database.
 
@@ -68,7 +68,7 @@ ForgeQE sends no telemetry and turns it off in everything it starts:
 
 An unchanged copy keeps following ForgeQE's updates; once you edit it, yours wins.
 
-For remote browsers, `forgeqe.yaml` can now point at provider-specific YAML files under `browser.providers` such as `browserstack` and `testmu`, so the BrowserStack or TestMu AI connection details do not have to live inline under `browser.remote`. `forgeqe init` drops sample files at `.forgeqe/browserstack.yaml` and `.forgeqe/testmu.yaml`. When both are present, the separate file supplies the provider defaults and the inline `browser.remote` values override only the active provider. ForgeQE's agent can also switch providers per request by passing `browser_provider` to `browser_run` or `run_test_cases`, and the CLI can pin one with `--browser-provider`.
+For remote browsers, `forgeqe.yaml` can now point at provider-specific YAML files under `browser.providers` such as `browserstack` and `testmu`, so the BrowserStack or TestMu AI connection details do not have to live inline under `browser.remote`. `forgeqe init` drops sample files at `.forgeqe/browserstack.yaml` and `.forgeqe/testmu.yaml`. When both are present, the separate file supplies the provider defaults and the inline `browser.remote` values override only the active provider. ForgeQE's agent can also switch providers per request by passing `browser_provider` to `browser_run` or `run_test_cases`, and the CLI can pin one with `--browser-provider`. ForgeQE drives remote browsers over CDP, so `remote.browser` must be Chrome or Edge, and the default endpoints are the providers' CDP (`/puppeteer`) ones. On a remote grid, the browser stops taking real clicks and keystrokes on a tab once a password form has been submitted (most likely the browser's password manager), so after a sign-in leaves the login page ForgeQE reopens the page it landed on in a fresh tab, with the session intact, and the run log says so.
 
 ```bash
 forgeqe models
@@ -240,7 +240,7 @@ Every suite writes `report.html`, `junit.xml`, and `suite.json` to `.forgeqe/rep
 
 ### Static BI
 
-`forgeqe bi` adds an offline BI layer on top of those reports. It exports curated CSV datasets from ForgeQE's own suite history and release-readiness reports, plus optional Azure DevOps WIQL and Jira JQL datasets from `bi.datasets` in `forgeqe.yaml`, scaffolds an [Evidence](https://github.com/evidence-dev/evidence) project, and runs `evidence build` to produce static HTML. No backend service stays up between runs: the refresh happens during `forgeqe bi sync` or `forgeqe bi build`, and the output is a static site in the configured build directory.
+`forgeqe bi` adds an offline BI layer on top of those reports. It exports curated CSV datasets from ForgeQE's own suite history and release-readiness reports, plus optional Azure DevOps WIQL and Jira JQL datasets from `bi.datasets` in `forgeqe.yaml`, into an [Evidence](https://github.com/evidence-dev/evidence) project that reads them through its CSV source, then runs `evidence sources` and `evidence build` to produce a static site in the configured build directory. ForgeQE uses the open-source Evidence line (`@evidence-dev/evidence` 40.x, pinned in the generated `package.json`), because the newer Evidence Studio CLI has no local build and keeps data in its cloud. Building it needs Node.js 18 or later; serve the folder to view it (`npx serve`), since it cannot load its data when opened from disk. When Node.js is missing or the Evidence build fails, `forgeqe bi build` writes ForgeQE's own self-contained page from the same data instead, which opens straight from disk, and says why; `--static` always does that, and `--evidence` fails instead of falling back. Dataset ids become table names (`forgeqe.<id>`), so they use letters, digits, and `_`. Pages ForgeQE generates carry a "Managed by forgeqe bi" comment in their front matter; a page without it is yours and is never overwritten. Tables with no rows yet stay out of the Evidence project (Evidence cannot build over an empty table), and their sections read "None yet." No backend service stays up between runs.
 
 ```yaml
 bi:
@@ -260,8 +260,9 @@ bi:
 ```
 
 ```bash
-forgeqe bi init
-forgeqe bi build
+forgeqe bi init            # scaffold the Evidence project and install its packages
+forgeqe bi build           # refresh the data and build the site (ForgeQE's own page if Evidence cannot build)
+forgeqe bi build --static  # ForgeQE's own page only, no Node.js needed
 ```
 
 ## Signing in

package/browserstack.example.yaml

@@ -1,6 +1,6 @@
 provider: browserstack
 remote:
-  browser: playwright-chromium
+  browser: chrome
   browser_version: latest
   os: osx
   os_version: sequoia

package/forgeqe.example.yaml

@@ -20,7 +20,7 @@ browser:
   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:                    # inline settings for the selected remote provider; override the provider file when both are set
-  #   browser: playwright-chromium   # BrowserStack: playwright-chromium / playwright-firefox / playwright-webkit
+  #   browser: chrome   # BrowserStack: chrome or edge (ForgeQE drives the browser over CDP)
   #   browser_version: latest
   #   os: osx
   #   os_version: sequoia
@@ -75,14 +75,6 @@ memory:
   dir: ./.forgeqe/memory # pages, elements, locators, and recorded flows
   replay: verify # verify | trust | off
 
-# Redis cache for deterministic external data fetches, such as BI datasets. Live browser runs still execute.
-# cache:
-#   redis_url: redis://127.0.0.1:6379
-#   key_prefix: forgeqe
-#   default_ttl_seconds: 3600
-#   bi_ttl_seconds: 900
-#   connect_timeout_ms: 3000
-
 code:
   # repo: ../my-app          # where passed runs become tests (default: the current folder; --no-code turns it off)
   # test_command: npx playwright test   # the repo's test command, for forgeqe heal; default: the agent finds it
@@ -121,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,6 +1,6 @@
 {
   "name": "@capagents/forgeqe",
-  "version": "1.1.3",
+  "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",
@@ -55,7 +55,6 @@
     "pixelmatch": "8.0.0",
     "pngjs": "7.0.0",
     "react": "^19.3.0",
-    "redis": "^4.7.1",
     "yaml": "^2.9.1"
   },
   "devDependencies": {

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,6 +44,7 @@ from .llm import (
     _agent_usage,
 )
 from .browser import (
+    FreshTabAfterPassword,
     browser_connection_label,
     browser_launch_kwargs,
     local_browser_launch_kwargs,
@@ -1105,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))
@@ -1153,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)