# TestMu AI MCP

> TestMu AI manages cross-browser testing data by letting your agent talk directly to your test automation builds. You can list build runs, check specific browser sessions, and pull deep debugging artifacts like video recordings, screenshots, console errors, or precise command logs—all through natural conversation. It gives you full control over complicated CI/CD quality assurance without ever leaving your chat window.

## Overview
- **Category:** ship-it
- **Price:** Free
- **Tags:** cross-browser-testing, automation-testing, selenium, playwright, visual-testing, ci-cd

## Description

Need to debug why a UI element failed on an old version of Safari? You don't have to jump between dashboards and log files anymore. This MCP connects your agent directly to TestMu AI, giving you immediate access to your entire cross-browser testing suite history. Instead of searching through complex UIs, you ask the questions—like 'Show me all build failures in staging' or 'Give me the full logs for session ABC.' Your agent handles the heavy lifting: it fetches everything from high-level aggregated telemetry on Selenium and Playwright builds to deep context within individual test sessions. You can pull absolute URLs for bug screenshots, retrieve full video recordings of browser executions, and extract command-level logs with exact timestamps. This capability is hosted on Vinkius, making sure any MCP-compatible client you use—whether it's Claude or Cursor—can access this crucial testing data. It's all about bringing your entire quality assurance pipeline into a natural conversation.

## Tools

### list_builds
Lists all completed automated test builds, grouping thousands of Selenium, Cypress, Playwright, or Appium tests into parent CI/CD build containers.

### get_build
Retrieves detailed telemetry for a specific test automation build run.

### list_sessions
Lists recent automated test sessions, providing the operating system, browser version, and final completion status.

### get_session
Gets deep context for a specific test session by identifying console errors, network configurations, and relevant URL artifacts.

### get_session_logs
Extracts precise command logs from the Selenium or Appium framework for a selected test run.

### get_screenshots
Fetches visual bug screenshots that were captured during a specific test session's failure hook.

### get_video
Retrieves the full video recording URL for any completed test execution.

### list_tunnels
Lists all active secure Tunnels, useful for monitoring localhost testing environments.

### list_platforms
Returns a complete list of every OS and browser combination that is currently supported in the testing grid.

### get_build_sessions
Extracts all explicit test sessions associated with a specific build run, allowing isolation of regression analysis.

## Prompt Examples

**Prompt:** 
```
List the last 5 automation builds in my TestMu AI account
```

**Response:** 
```
I've retrieved the latest 5 builds. Highlights include 'Prod-Regression-987' (Passed), 'Staging-UI-Check-986' (Failed - 12 sessions), and 'Critical-Hotfix-985' (Passed). Would you like to see the test sessions for the failed staging build?
```

**Prompt:** 
```
Show me the logs and screenshots for session ID 'abc-123-xyz'
```

**Response:** 
```
Retrieving data for session 'abc-123-xyz'… I've fetched 3 failure screenshots and the full Selenium command logs. The console shows a 'NoSuchElementException' at the login flow. Would you like the video recording link as well?
```

**Prompt:** 
```
Which OS and browser versions are currently supported in the grid?
```

**Response:** 
```
I've queried the platform capabilities. Currently supported: Windows 11 (Chrome 120+, Firefox 118+), macOS Sonoma (Safari 17, Chrome 120+), and latest Android/iOS versions. I can provide the full JSON matrix if you need specific sub-versions.
```

## Capabilities

### Audit Build Status
Lists every test automation build and provides high-level telemetry for Selenium, Playwright, or Cypress suites.

### Inspect Test Sessions
Deep dives into a single browser run to extract console errors, network data, and metadata needed for debugging specific UI failures.

### Fetch Visual Artifacts
Retrieves absolute URLs for bug screenshots or full video recordings of any test execution.

### Get Command Logs
Extracts precise, command-level logs from the testing framework, including W3C WebDriver protocols and timestamps.

### Verify Platform Support
Queries the grid to list exactly which combinations of macOS, Windows, iOS, and Android versions are available for testing.

## Use Cases

### Diagnosing a Flaky Login Bug
A developer notices a login issue only on older Android versions. They ask their agent to check the platform support using `list_platforms`. Then, they use `get_session` on a failing session ID to get console errors and network configs, quickly pinpointing if it's an authentication timeout or a UI element failure.

### Auditing Pre-Release Builds
A DevOps team member needs to verify the health of the latest release candidate. They ask their agent to `list_builds` and filter for 'Staging.' The agent returns aggregated telemetry, confirming that all critical Playwright suites passed before approval.

### Tracking a Specific Regression
A QA engineer finds an unexpected failure in the staging environment. They use `get_build_sessions` tied to the build ID, narrowing down the issue to one specific session. Then they grab `get_video` and `get_screenshots` for that session to show their manager.

### Checking Environment Scope
A team is planning a new feature requiring iOS 17 support. They ask the agent to check supported capabilities via `list_platforms`, confirming that the necessary OS/browser combination exists before committing development resources.

## Benefits

- Stop switching tabs. Instead of jumping to a dashboard to see build status, ask your agent to list all test automation builds using the `list_builds` tool. You get the high-level overview immediately.
- No more guessing why something broke. If you find an issue, use `get_session` to pull deep context on that specific failure, grabbing console errors and network details without leaving your chat window.
- Instant visual proof: Need to show a bug? Use `get_screenshots` or `get_video` to fetch the absolute URL for the exact screenshot or video recording of the failure. It's instant evidence.
- Mastering regressions is easier with `get_build_sessions`. If a build fails, you can ask your agent to pull all related test sessions so you know exactly which part of the test suite needs fixing.
- Verify compatibility before writing code. Use `list_platforms` to confirm that Windows 11/Chrome or macOS Sonoma/Safari is actually available in the grid. You'll never be surprised by missing capabilities again.

## How It Works

The bottom line is: it turns complex, multi-tab debugging into a simple conversation with your AI client.

1. Subscribe to this MCP and enter your TestMu AI Username and Access Key.
2. Connect the service to your preferred agent (Claude, Cursor, etc.).
3. Tell your agent what you need—for example, 'Show me all build failures from last night'—and get the data returned instantly.

## Frequently Asked Questions

**How do I use TestMu AI to check if a specific browser version is supported?**
Use the `list_platforms` tool. This function returns an exact matrix of all OS and browser versions currently available in the testing grid, so you know what environments your code will actually run on.

**Can TestMu AI help me find command logs for a failed test?**
Yes. Use `get_session_logs` to extract precise Selenium or Appium command logs. This gives developers the low-level protocol data needed to understand exactly where the testing framework broke.

**What is the difference between listing builds and getting build telemetry with TestMu AI?**
The `list_builds` tool shows you a list of all completed runs. The `get_build` tool takes one specific ID from that list and returns highly detailed metrics for *that* single run.

**Does TestMu AI only provide screenshots, or can it give me videos?**
It provides both. You can use `get_screenshots` for immediate visual bugs, or you can use the `get_video` tool to retrieve a full video recording of the entire test execution.

**If I have multiple builds, how do I check all sessions?**
First, run `list_builds` to identify the build you care about. Then, use `get_build_sessions` with that specific build ID to pull every single test session associated with it for review.