Save an authentication profile for use in test runs.

Args: profile_name: Unique name for this profile auth_type: One of "env_login", "storage_state", or "cookie_json" login_url: Login page URL (required for env_login) username_env: Name of env var holding the username (default: TEST_USERNAME) password_env: Name of env var holding the password (default: TEST_PASSWORD) storage_state_path: Path to a Playwright storage_state.json file cookie_json_path: Path to a JSON file containing cookie objects user_data_dir: Optional path to a persistent Chromium profile directory (helps with anti-bot OAuth)

Returns: dict with profile_name, auth_type, status, note

Open a headed browser for interactive OAuth/MFA login and save the session state.

A browser window opens — complete Google/GitHub OAuth or any MFA flow manually. The tool polls the URL every 500ms and saves storage state automatically once login succeeds.

Args: profile_name: Name to save the auth profile under login_url: URL of the login page to open success_url_pattern: URL substring that indicates successful login (e.g. "/dashboard") If omitted, any URL change away from login_url counts as success timeout_secs: Max seconds to wait for login (default: 120) user_data_dir: Optional path to a persistent Chromium profile dir (for OAuth providers that detect fresh browser contexts as bots, e.g. Google, LinkedIn)

Returns: dict with profile_name, requested_profile_name, status ("captured" | "timeout" | "error"), storage_state_path, note

Run a browser agent for a natural-language task and return a rich evaluation report.

One-shot evaluator — give it a URL and a task, get back a structured report with screenshots, console errors, network failures, and an agent step timeline. No need to discover/record/replay first.

Args: app_url: The website URL to evaluate task: Natural-language description of what to test (e.g. "Try the signup flow and note UX issues") profile_name: Optional auth profile name for authenticated pages headless: Run browser in headless mode (default: False — shows the browser) max_steps: Maximum agent steps (default: 25) capture: Evidence to capture: "screenshots", "console", "network", "trace" (default: all four) format: Report format: "markdown" (default), "text", or "json" save_as_recorded_flow: If True, promote the evaluation into a recorded flow for regression flow_name: Flow name to use when saving as recorded flow (auto-generated if omitted)

Returns: dict with summary, agent_steps, evidence (console_errors, network_failures, screenshots, trace_path), pass_fail, run_id, and formatted_report

Cancel a running test and mark it as cancelled.

Args: run_id: The run_id to cancel

Returns: dict with run_id, previous_status, new_status

Record a test flow by running a Browser-Use agent to accomplish a goal.

Captures each action with selector, target_text, dom_fingerprint, per-step screenshots, and generates final assertion steps from a Gemini screenshot analysis.

Args: app_url: The website URL to test flow_name: Short name for this flow (used as identifier) goal: Plain-English description of what to accomplish profile_name: Optional auth profile name (from save_auth_profile) command: Optional natural language command for additional context business_criticality: "revenue" | "activation" | "retention" | "support" | "other"

Returns: dict with flow_id, flow_name, step_count, status, artifacts_dir

Package reusable authenticated SaaS goldens into strict-step release-gate flows.

Use this after discovery or live exploration when you know the stable semantic path you want to gate on. It promotes curated recipes into recorded flows that replay in strict_steps mode and are ready for run_release_check(mode="replay").

Supported recipe_type values:

• role_click_to_url

• role_click_to_text

• selector_then_role_to_url

• text_click_to_text

• text_then_text_to_text

• text_then_selector_to_text

Get structured results for a test run.

Prefer run_release_check + blop://release/{release_id}/brief for release gating. This tool remains the detailed run-level payload, now with summary-first fields.

Args: run_id: The run_id returned from run_regression_test

Returns: dict with run_id, status, cases (with assertion_results, replay_mode_used, step_failure_index, artifact_paths), severity_counts, failed_cases, next_actions

Derive process-mining style variants from run health events (optional PM4Py when installed).

Uses replay_step_completed and other health events. Install blop-mcp[insights] for PM4Py stats.

Export OTLP-shaped JSON (resourceSpans) for a run — local SQLite only, no network upload.

Re-run a failed test case in headed mode with verbose evidence capture.

Shows the exact step that failed, repair attempt results, per-step screenshots, and a plain-English "why this failed" explanation with concrete next actions.

Args: run_id: The run_id containing the failure case_id: The case_id of the specific failure to debug

Returns: dict with case_id, run_id, status, screenshots, console_log, repro_steps, step_failure_index, replay_mode, assertion_failures, why_failed

O(1) probe: package version, surface flags, registered tool count, and canonical tool names.

Use this or the blop://health resource before heavier discovery or replay work.

Preflight check before a release: verifies API key, Chromium, DB, app reachability, and auth profile.

This is the canonical MVP entry point — run this before discover_critical_journeys or run_release_check.

Args: check_mobile: If True, also checks Appium server reachability for mobile testing.

Crawl app_url and plan 3-8 critical user journeys in business language.

Returns CriticalJourney objects with why_it_matters and include_in_release_gating fields so you can immediately scope which journeys gate a release. Revenue and activation journeys are automatically flagged for release gating.

Flagship release confidence tool: replay critical journeys and return a SHIP / INVESTIGATE / BLOCK decision.

In replay mode (default), queues a regression run and returns immediately with run_id for polling. In targeted mode, runs a one-shot agent evaluation synchronously as a shortcut smoke check.

Args: journey_ids: deprecated alias for flow_ids. flow_ids: recorded flow IDs to replay. If omitted, uses all flows matching criticality_filter. criticality_filter: defaults to ["revenue", "activation"]. release_id: optional caller-supplied release identifier (auto-generated if omitted). mode: "replay" (default, golden path for release gating) or "targeted" (one-shot eval). smoke_preflight: Optional advisory smoke sweep before replay. Does not block the release on its own.

Root-cause evidence + next actions for a release blocker.

Accepts any of: run_id, release_id, flow_id, journey_id, incident_cluster_id (at least one required). Returns BlockerTriage with likely_cause, evidence_summary, user_business_impact, recommended_action, suggested_owner, and linked_artifacts.

QA-engineering view: test pyramid health, coverage gaps, flakiness signals, and prioritized recommendations.

Aggregates recorded journeys and recent run cases for app_url, then returns a RecommendationSet plus embedded qa_context (risk matrix, defect mix, pyramid stats). Use scope to narrow the recommendation lists.

Return compact workspace metadata, resource URIs, and discovery defaults.

Return structured release brief (decision, risk, blockers) for a release_id.

List recorded journeys filtered by release brief app_url or explicit app_url.

Batch: release context plus journeys for the release app URL in one call.

Summaries and acceptance-style criteria from recorded flows / release brief (no external PRD yet).

Static UX/criticality hints for planning (cached, small JSON).

Navigate the shared browser session to a URL (ok/data envelope).

Open a recorded journey's entry URL (flow_id == journey_id).

Compact interactive DOM snapshot (ARIA-ish) for the current page.

One structured step: click | type | wait | press_key | navigate (see PerformStepSpec).

Capture screenshot, dom_snapshot, or network_log; optional run_id routes under runs/.

Idempotent agent observation keyed by (run_id, observation_key).