playwright-e2e-mcp 0.8.0 → 0.10.0

package/README.md

@@ -67,7 +67,7 @@ red at HEAD ─▶ bisect-failure (runs it across git history, names the breakin
 - **Lean.** With the `core` tool set, finding and fixing a broken locator took about **5,500 tokens**
   versus about **7,900** with Playwright MCP plus a shell. All 19 tools add about 16k tokens of
   definitions to every request, so load only the [profiles](#configuration) you use ([benchmark](#benchmark)).
-- **Free and open source.** MIT, no account, no API key, no telemetry. Every tool is free; an optional paid Pro only adds hosted CI history.
+- **Free and open source.** MIT, no account, no API key, no telemetry. Every tool and feature is free, including the shared team history server you can host yourself.
 
 ## 🚀 What only this MCP does
 
@@ -273,8 +273,8 @@ Running and fixing your own tests needs your project, so use the local install f
 | --- | --- |
 | Skill only, any agent | `npx skills add xsignon-secure/E2E` |
 | MCP Registry | `io.github.xsignon-secure/E2E` ([listing](https://registry.modelcontextprotocol.io/)); registry-aware clients find it there |
-| Straight from GitHub, no npm | `npx -y github:xsignon-secure/E2E#v0.8.0` (pin a release tag) |
-| Release tarball | `npm install -D https://github.com/xsignon-secure/E2E/releases/download/v0.8.0/playwright-e2e-mcp-0.8.0.tgz` |
+| Straight from GitHub, no npm | `npx -y github:xsignon-secure/E2E#v0.10.0` (pin a release tag) |
+| Release tarball | `npm install -D https://github.com/xsignon-secure/E2E/releases/download/v0.10.0/playwright-e2e-mcp-0.10.0.tgz` |
 | Docker | `docker run -i --rm -v "$PWD:/work" ghcr.io/xsignon-secure/playwright-e2e-mcp` (published on each release; see [Development](docs/development.md#docker)) |
 | Local checkout | `"command": "node", "args": ["/path/to/E2E/dist/index.js"]` |
 
@@ -338,6 +338,27 @@ in the project, else `python3` / `python`.
 pip install pytest-playwright && playwright install chromium
 ```
 
+## What's new in 0.10
+
+- **Asks before changing your files.** Applying a fix, writing a new test, quarantining a test or
+  replacing a visual baseline now shows you the exact change and waits for your yes, in clients
+  that support MCP questions (elicitation). No writes nothing. `PW_MCP_CONFIRM_WRITES` sets the
+  policy (`auto`, `always`, `off`).
+- **Interactive test report** in Claude, ChatGPT, Cursor and other MCP Apps clients: counts,
+  a filterable list of failures, expected vs. received, and one-click re-run or "Ask to fix".
+  Other clients show the text result as before. `PW_MCP_APPS=0` turns it off.
+- **Newer sign-in for the hosted endpoint:** OAuth clients can identify with a Client ID
+  Metadata Document (the MCP default since 2025-11-25); dynamic registration keeps working.
+
+## What's new in 0.9
+
+- **Everything is free, including team history.** The CI history service that used to be a
+  paid add-on is now in this repo as a [self-hosted history server](history-server/README.md)
+  (MIT): one `docker run`, plain Node, or a free Vercel or Azure account. You hand out the
+  tokens; there is no account or billing anywhere.
+- **New names:** `PW_MCP_HISTORY_URL` / `PW_MCP_HISTORY_TOKEN` and the Action's `history-url` /
+  `history-token`. The old `PW_MCP_PRO_*`, `pro-url` and `pro-key` names keep working.
+
 ## What's new in 0.8
 
 - **Python suites:** projects that use `pytest-playwright` work with `run-test`, `get-failure`
@@ -472,19 +493,25 @@ steps:
   - uses: actions/setup-node@v6
     with: { node-version: 24 }
   - run: npm ci && npx playwright install --with-deps chromium
-  - uses: xsignon-secure/E2E@v0.8.0
+  - uses: xsignon-secure/E2E@v0.10.0
     with:
       flaky-runs: 3      # 0 skips the flaky verdict
       suggest: 2         # suggest-fix diffs for the first 2 failures
       # args: --browser chromium tests/checkout
 ```
 
-A complete, ready-to-copy workflow is available in [`examples/github-actions/playwright-e2e.yml`](examples/github-actions/playwright-e2e.yml), including artifact upload and commented options for `guard: true` and Pro Cloud.
+A complete, ready-to-copy workflow is available in [`examples/github-actions/playwright-e2e.yml`](examples/github-actions/playwright-e2e.yml), including artifact upload and commented options for `guard: true` and a shared history server.
 
 **GitLab CI:** [`examples/gitlab-ci/playwright-e2e.yml`](examples/gitlab-ci/playwright-e2e.yml) runs the heal guard on merge requests, the same `ci` diagnosis, and posts the report as a merge request comment when you give it a project access token. Any other CI (Jenkins, CircleCI, AWS CodeBuild) works the same way: run `npx -y playwright-e2e-mcp ci --output e2e-report.md` and keep the file.
 
+**Team history across machines (free, self-hosted):** CI runs normally stay on the CI machine.
+Run the [history server](history-server/README.md) from this repo (one `docker run`, or a free
+Vercel, Azure or any Node host), give the Action `history-url` and `history-token`, and every
+CI run lands in one history that `analyze-history` on your laptop and the server's dashboard
+both read. No account, no billing; you hand out the tokens.
+
 Inputs: `project-root`, `args`, `flaky-runs`, `suggest`, `comment`, `review`,
-`verify-fixes`, `guard`, `pro-key`, `pro-url`, `fail-on-failure`, `version`, `github-token`. Outputs: `exit-code`,
+`verify-fixes`, `guard`, `history-token`, `history-url`, `fail-on-failure`, `version`, `github-token`. Outputs: `exit-code`,
 `report`, `guard`.
 
 Quarantined tests (`playwright-quarantine.json`, see [`quarantine`](docs/tools.md#quarantine))
@@ -510,19 +537,22 @@ npx -y playwright-e2e-mcp guard --base origin/main   # exit 1 on BLOCK; --strict
 | `PW_MCP_OUTPUT_SCHEMAS` | on | `0` leaves the output schemas out of the tool list to save context. Results still carry `structuredContent` (see [Structured results](docs/tools.md#structured-results)) |
 | `PW_MCP_PROTOCOL` | both | `legacy` stops offering the stateless 2026-07-28 MCP revision, for a client that trips over it. By default 2026 clients get it and 2025 clients get the old handshake |
 | `PW_MCP_NO_UPDATE_CHECK` | off | `1` stops `doctor` from asking npm whether a newer version is out (same as `doctor --offline`) |
+| `PW_MCP_CONFIRM_WRITES` | `auto` | Ask before a tool changes your files (`suggest-fix` apply, `audit-tests` fix, a new test from `generate-e2e-test`, quarantine add/remove, replacing a visual baseline). `auto` asks when the client can show a question (MCP elicitation) and writes as before when it can't; `always` refuses to write when the client can't ask; `off` never asks. The question shows the exact diff, and a yes only covers that diff |
+| `PW_MCP_APPS` | `1` | Show an interactive test report next to `run-test`, `get-run-status` and `get-failure` results in clients that support MCP Apps (Claude, ChatGPT, Cursor). The report filters failures, shows expected vs. received, and re-runs or asks to fix a test with one click. `0` turns it off; other clients show the text result as before |
 | `PW_MCP_SKILLS` | on | `0` stops serving the bundled agent skill over the MCP Skills extension (`skill://playwright-e2e-mcp/SKILL.md`) |
 | `PW_MCP_STORAGE_STATE` | — | Default `storageState` file (inside the project) for the page tools |
 | `PW_MCP_PYTHON` | project venv, then `python3` | The Python that runs a pytest-playwright suite |
 | `PW_MCP_BLOCK_WRITES` | off | `1` makes the page tools abort POST, PUT, PATCH and DELETE requests that no mock answers (same as `blockWrites: true`), so steps run against a real environment cannot change its data |
 | `PW_MCP_SHUFFLE_SEEDS` | random | Comma-separated seeds for `diagnose-flaky`'s `order` pass, to replay the orders a diagnosis reported |
 | `PW_MCP_LOGIN_ENV` | — | Extra environment variables `save-login` may type through `{{env:NAME}}`, comma separated. Without it only `E2E_*`, `TEST_*`, `PW_*`, `PLAYWRIGHT_*` and `LOGIN_*` are allowed |
-| `PW_MCP_PRO_KEY` / `PW_MCP_PRO_URL` | — | Optional, paid: Pro key and Pro Cloud address. CI runs are uploaded with `playwright-e2e-mcp upload` (or the Action's `pro-key` / `pro-url` inputs) and `analyze-history` merges them with local runs. Unset (the default), nothing is ever sent anywhere |
+| `PW_MCP_HISTORY_URL` / `PW_MCP_HISTORY_TOKEN` | — | Optional: your team's [history server](history-server/README.md) (free, self-hosted) and a token from it. CI runs are uploaded with `playwright-e2e-mcp upload` (or the Action's `history-url` / `history-token` inputs) and `analyze-history` merges them with local runs. Unset (the default), nothing is ever sent anywhere. The 0.7/0.8 names `PW_MCP_PRO_KEY` / `PW_MCP_PRO_URL` still work |
 | `PW_MCP_HISTORY` | on | `0` stops recording runs to `.playwright-e2e-mcp/history.jsonl` |
 | `PW_MCP_ALLOWED_ROOTS` | — | Extra directories a caller may pass as `projectRoot` (`:`-separated, `;` on Windows). Anything outside these and the default root is rejected |
 | `PW_MCP_HTTP_TOKEN` | — | HTTP bridge only: bearer token that unlocks all tools: 16+ characters, 32+ recommended (see [Hosted endpoint](docs/hosted-endpoint.md)) |
 | `PW_MCP_ALLOWED_HOSTS` | localhost + Vercel hostnames when there is no token | HTTP bridge only: comma-separated `Host` allowlist; `*` accepts any |
 | `PW_MCP_MAX_FAILED_AUTH` | `20` | HTTP bridge only: wrong tokens or access keys one client address may send in 15 minutes before it gets `429` |
 | `PW_MCP_OAUTH_REDIRECT_HOSTS` | any https host | HTTP bridge only: comma-separated hosts OAuth apps may return to, e.g. `claude.ai,chatgpt.com`; `.example.com` covers subdomains; localhost always works |
+| `PW_MCP_OAUTH_CIMD` | `1` | HTTP bridge only: accept OAuth clients that identify with a Client ID Metadata Document (an https `client_id`, the MCP default since 2025-11-25); `0` accepts only dynamically registered clients |
 | `PW_MCP_TRUST_PROXY` | off (on for Vercel) | HTTP bridge only: `1` trusts `X-Real-IP` / `X-Forwarded-For` from a reverse proxy in front, so the sign-in limit counts per client, not per proxy |
 | `PW_MCP_PASSTHROUGH_ENV` | — | HTTP bridge only: comma-separated extra variables passed to test runs (e.g. `BASE_URL`) |
 | `PW_MCP_MAX_CHILDREN` | `4` | HTTP bridge only: how many test runs and browser probes may run at once |
@@ -574,9 +604,9 @@ A real `run-test` call served over stdio by `npx -y playwright-e2e-mcp` against
 
 ## Free and open source
 
-- **MIT licensed.** Use it, change it, ship it in commercial work; no fees, no feature held back. The optional Pro plan adds a hosted service (CI run history across machines), not tools; nothing here needs it.
+- **MIT licensed.** Use it, change it, ship it in commercial work; no fees, no paid tier, no feature held back. That includes the [team history server](history-server/README.md) that collects CI runs from every machine: it is in this repo, and you host it yourself for free.
 - **No account, no API key, no sign-up.** `npx -y playwright-e2e-mcp init` is the whole setup.
-- **No telemetry.** It never phones home; your tests, traces and run history stay on your machine unless you set a Pro key and upload them. The only other request is `doctor` asking npm for the latest version number when you run it (`--offline` or `PW_MCP_NO_UPDATE_CHECK=1` skips it).
+- **No telemetry.** It never phones home; your tests, traces and run history stay on your machine unless you point it at your own history server and upload them. The only other request is `doctor` asking npm for the latest version number when you run it (`--offline` or `PW_MCP_NO_UPDATE_CHECK=1` skips it).
 - **Free dependencies only:** the MCP SDK (Apache-2.0), zod (MIT), axe-core (MPL-2.0) and the Playwright your project already has (Apache-2.0).
 - **Free to host yourself**, too: the HTTP bridge deploys to a free Vercel account (see [Hosted endpoint](docs/hosted-endpoint.md)).
 

package/dist/apps/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * MCP Apps (SEP-1865, extension `io.modelcontextprotocol/ui`): an
+ * interactive test report that Claude, ChatGPT, Cursor and other MCP Apps
+ * hosts render next to the run-test, get-run-status and get-failure results.
+ *
+ * The tools say which view to show in their `_meta.ui.resourceUri`; the
+ * host reads the `ui://` resource, renders it in a sandboxed iframe and
+ * hands it the tool result. Hosts that do not support MCP Apps ignore the
+ * metadata and show the text result exactly as before, so nothing changes
+ * for them.
+ *
+ * The view makes no network requests (it declares no CSP domains) and only
+ * calls this server's own tools through the host.
+ *
+ * Set PW_MCP_APPS=0 to turn it off.
+ */
+import type { McpServer } from '@modelcontextprotocol/server';
+/** The MCP Apps resource MIME type (`text/html;profile=mcp-app`). */
+export declare const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
+/** Older hosts read the view from this flat key (`ui/resourceUri`). */
+export declare const LEGACY_RESOURCE_URI_KEY = "ui/resourceUri";
+export declare const TEST_REPORT_URI = "ui://playwright-e2e-mcp/test-report.html";
+/** Tools whose results the report view can show. */
+export declare const REPORT_TOOLS: ReadonlySet<string>;
+export declare function appsEnabled(): boolean;
+/** The `_meta` a tool declares so MCP Apps hosts show the report, or undefined. */
+export declare function appMetaFor(toolName: string): Record<string, unknown> | undefined;
+/** Register the report view resource. A no-op when PW_MCP_APPS=0. */
+export declare function registerApps(server: McpServer): void;

package/dist/apps/index.js

@@ -0,0 +1,52 @@
+/**
+ * MCP Apps (SEP-1865, extension `io.modelcontextprotocol/ui`): an
+ * interactive test report that Claude, ChatGPT, Cursor and other MCP Apps
+ * hosts render next to the run-test, get-run-status and get-failure results.
+ *
+ * The tools say which view to show in their `_meta.ui.resourceUri`; the
+ * host reads the `ui://` resource, renders it in a sandboxed iframe and
+ * hands it the tool result. Hosts that do not support MCP Apps ignore the
+ * metadata and show the text result exactly as before, so nothing changes
+ * for them.
+ *
+ * The view makes no network requests (it declares no CSP domains) and only
+ * calls this server's own tools through the host.
+ *
+ * Set PW_MCP_APPS=0 to turn it off.
+ */
+import { TEST_REPORT_HTML } from './test-report-html.js';
+/** The MCP Apps resource MIME type (`text/html;profile=mcp-app`). */
+export const MCP_APP_MIME_TYPE = 'text/html;profile=mcp-app';
+/** Older hosts read the view from this flat key (`ui/resourceUri`). */
+export const LEGACY_RESOURCE_URI_KEY = 'ui/resourceUri';
+export const TEST_REPORT_URI = 'ui://playwright-e2e-mcp/test-report.html';
+/** Tools whose results the report view can show. */
+export const REPORT_TOOLS = new Set(['run-test', 'get-run-status', 'get-failure']);
+export function appsEnabled() {
+    return process.env.PW_MCP_APPS !== '0';
+}
+/** The `_meta` a tool declares so MCP Apps hosts show the report, or undefined. */
+export function appMetaFor(toolName) {
+    if (!appsEnabled() || !REPORT_TOOLS.has(toolName))
+        return undefined;
+    return { ui: { resourceUri: TEST_REPORT_URI }, [LEGACY_RESOURCE_URI_KEY]: TEST_REPORT_URI };
+}
+/** Rendering hints for the host: a border, and no outside origins at all. */
+const RESOURCE_UI_META = {
+    prefersBorder: true,
+    csp: { connectDomains: [], resourceDomains: [] },
+};
+/** Register the report view resource. A no-op when PW_MCP_APPS=0. */
+export function registerApps(server) {
+    if (!appsEnabled())
+        return;
+    server.registerResource('test-report', TEST_REPORT_URI, {
+        title: 'Interactive test report',
+        description: 'The view MCP Apps hosts show for run-test, get-run-status and get-failure results.',
+        mimeType: MCP_APP_MIME_TYPE,
+        _meta: { ui: RESOURCE_UI_META },
+    }, async () => ({
+        contents: [{ uri: TEST_REPORT_URI, mimeType: MCP_APP_MIME_TYPE, text: TEST_REPORT_HTML, _meta: { ui: RESOURCE_UI_META } }],
+    }));
+}
+//# sourceMappingURL=index.js.map

package/dist/apps/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/apps/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,qEAAqE;AACrE,MAAM,CAAC,MAAM,iBAAiB,GAAG,2BAA2B,CAAC;AAE7D,uEAAuE;AACvE,MAAM,CAAC,MAAM,uBAAuB,GAAG,gBAAgB,CAAC;AAExD,MAAM,CAAC,MAAM,eAAe,GAAG,0CAA0C,CAAC;AAE1E,oDAAoD;AACpD,MAAM,CAAC,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC,CAAC,UAAU,EAAE,gBAAgB,EAAE,aAAa,CAAC,CAAC,CAAC;AAExG,MAAM,UAAU,WAAW;IACzB,OAAO,OAAO,CAAC,GAAG,CAAC,WAAW,KAAK,GAAG,CAAC;AACzC,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,UAAU,CAAC,QAAgB;IACzC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC;QAAE,OAAO,SAAS,CAAC;IACpE,OAAO,EAAE,EAAE,EAAE,EAAE,WAAW,EAAE,eAAe,EAAE,EAAE,CAAC,uBAAuB,CAAC,EAAE,eAAe,EAAE,CAAC;AAC9F,CAAC;AAED,6EAA6E;AAC7E,MAAM,gBAAgB,GAAG;IACvB,aAAa,EAAE,IAAI;IACnB,GAAG,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE;CACjD,CAAC;AAEF,qEAAqE;AACrE,MAAM,UAAU,YAAY,CAAC,MAAiB;IAC5C,IAAI,CAAC,WAAW,EAAE;QAAE,OAAO;IAC3B,MAAM,CAAC,gBAAgB,CACrB,aAAa,EACb,eAAe,EACf;QACE,KAAK,EAAE,yBAAyB;QAChC,WAAW,EAAE,oFAAoF;QACjG,QAAQ,EAAE,iBAAiB;QAC3B,KAAK,EAAE,EAAE,EAAE,EAAE,gBAAgB,EAAE;KAChC,EACD,KAAK,IAAI,EAAE,CAAC,CAAC;QACX,QAAQ,EAAE,CAAC,EAAE,GAAG,EAAE,eAAe,EAAE,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,gBAAgB,EAAE,EAAE,CAAC;KAC3H,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/apps/test-report-html.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The interactive test report view (MCP Apps, SEP-1865).
+ *
+ * One self-contained HTML page with no external requests: the host loads it
+ * in a sandboxed iframe and talks to it with JSON-RPC over postMessage. The
+ * page speaks the small part of the MCP Apps protocol it needs directly
+ * (ui/initialize, tool-input, tool-result, tools/call, ui/message,
+ * size-changed), so it ships no framework and no bundle.
+ *
+ * Everything from the tool result is written with textContent, never as
+ * HTML: test titles and error messages come from the project under test.
+ *
+ * Kept as a TypeScript string so `tsc` ships it in dist/ with the server.
+ */
+export declare const TEST_REPORT_HTML: string;

package/dist/apps/test-report-html.js

@@ -0,0 +1,430 @@
+/**
+ * The interactive test report view (MCP Apps, SEP-1865).
+ *
+ * One self-contained HTML page with no external requests: the host loads it
+ * in a sandboxed iframe and talks to it with JSON-RPC over postMessage. The
+ * page speaks the small part of the MCP Apps protocol it needs directly
+ * (ui/initialize, tool-input, tool-result, tools/call, ui/message,
+ * size-changed), so it ships no framework and no bundle.
+ *
+ * Everything from the tool result is written with textContent, never as
+ * HTML: test titles and error messages come from the project under test.
+ *
+ * Kept as a TypeScript string so `tsc` ships it in dist/ with the server.
+ */
+export const TEST_REPORT_HTML = String.raw `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Playwright test report</title>
+<style>
+:root {
+  --bg: var(--color-background-primary, #ffffff);
+  --bg2: var(--color-background-secondary, #f5f6f8);
+  --fg: var(--color-text-primary, #1d2125);
+  --fg2: var(--color-text-secondary, #5b636b);
+  --line: var(--color-border-primary, #dfe2e6);
+  --ok: var(--color-text-success, #1f7a3d);
+  --bad: var(--color-text-danger, #b42318);
+  --warn: var(--color-text-warning, #9a6700);
+  --okbg: var(--color-background-success, #e7f6ec);
+  --badbg: var(--color-background-danger, #fdecea);
+  --warnbg: var(--color-background-warning, #fff4d6);
+  --radius: var(--border-radius-md, 8px);
+  --sans: var(--font-sans, system-ui, -apple-system, "Segoe UI", sans-serif);
+  --mono: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace);
+}
+:root[data-theme="dark"] {
+  --bg: var(--color-background-primary, #17191c);
+  --bg2: var(--color-background-secondary, #212429);
+  --fg: var(--color-text-primary, #e8eaed);
+  --fg2: var(--color-text-secondary, #a2a9b1);
+  --line: var(--color-border-primary, #33373d);
+  --ok: var(--color-text-success, #6fd08c);
+  --bad: var(--color-text-danger, #ff8a80);
+  --warn: var(--color-text-warning, #f2c94c);
+  --okbg: var(--color-background-success, #17301f);
+  --badbg: var(--color-background-danger, #3a1d1b);
+  --warnbg: var(--color-background-warning, #3a3117);
+}
+* { box-sizing: border-box; }
+html, body { margin: 0; background: var(--bg); color: var(--fg); font: 14px/1.45 var(--sans); }
+main { padding: 14px 16px 16px; }
+h1 { font-size: 15px; margin: 0 0 10px; display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+.badge { font-size: 12px; font-weight: 600; padding: 2px 8px; border-radius: 999px; }
+.badge.ok { background: var(--okbg); color: var(--ok); }
+.badge.bad { background: var(--badbg); color: var(--bad); }
+.badge.warn { background: var(--warnbg); color: var(--warn); }
+.stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(84px, 1fr)); gap: 8px; margin-bottom: 12px; }
+.stat { background: var(--bg2); border-radius: var(--radius); padding: 8px 10px; }
+.stat b { display: block; white-space: nowrap; font-size: 18px; font-variant-numeric: tabular-nums; }
+.stat span { color: var(--fg2); font-size: 12px; }
+.stat.failed b { color: var(--bad); }
+.stat.passed b { color: var(--ok); }
+.stat.flaky b { color: var(--warn); }
+.bar { display: flex; height: 6px; border-radius: 3px; overflow: hidden; background: var(--bg2); margin-bottom: 12px; }
+.bar i { display: block; }
+.toolbar { display: flex; gap: 8px; margin-bottom: 8px; }
+input[type=search] { flex: 1; min-width: 0; padding: 6px 10px; border: 1px solid var(--line); border-radius: var(--radius); background: var(--bg); color: var(--fg); font: inherit; }
+ul { list-style: none; margin: 0; padding: 0; }
+li.failure { border: 1px solid var(--line); border-radius: var(--radius); margin-bottom: 8px; overflow: hidden; }
+li.failure > button.head { all: unset; cursor: pointer; display: block; width: 100%; padding: 8px 10px; box-sizing: border-box; }
+li.failure > button.head:focus-visible { outline: 2px solid var(--color-ring-primary, #3b82f6); outline-offset: -2px; }
+.title { font-weight: 600; word-break: break-word; }
+.where { color: var(--fg2); font: 12px var(--mono); word-break: break-all; }
+.kind { font-size: 11px; text-transform: uppercase; letter-spacing: .04em; color: var(--bad); margin-left: 6px; }
+.body { padding: 0 10px 10px; display: none; }
+li.open .body { display: block; }
+pre { margin: 6px 0; padding: 8px; background: var(--bg2); border-radius: 6px; font: 12px/1.4 var(--mono); white-space: pre-wrap; word-break: break-word; max-height: 260px; overflow: auto; }
+.cmp { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
+.cmp div > span { font-size: 12px; color: var(--fg2); }
+@media (max-width: 480px) { .cmp { grid-template-columns: 1fr; } }
+.actions { display: flex; gap: 6px; flex-wrap: wrap; margin-top: 6px; }
+button.act { font: inherit; font-size: 13px; padding: 5px 10px; border-radius: var(--radius); border: 1px solid var(--line); background: var(--bg); color: var(--fg); cursor: pointer; }
+button.act.primary { background: var(--fg); color: var(--bg); border-color: var(--fg); }
+button.act:disabled { opacity: .55; cursor: default; }
+.muted { color: var(--fg2); }
+.note { font-size: 12px; color: var(--fg2); margin-top: 10px; }
+.empty { padding: 18px; text-align: center; color: var(--fg2); background: var(--bg2); border-radius: var(--radius); }
+.spin { display: inline-block; width: 10px; height: 10px; border: 2px solid var(--fg2); border-right-color: transparent; border-radius: 50%; animation: s 0.8s linear infinite; }
+@keyframes s { to { transform: rotate(360deg); } }
+@media (prefers-reduced-motion: reduce) { .spin { animation: none; } }
+</style>
+</head>
+<body>
+<main id="root"><p class="muted"><span class="spin"></span> Waiting for the test results…</p></main>
+<script>
+(function () {
+  "use strict";
+  var root = document.getElementById("root");
+  var nextId = 1;
+  var pending = {};
+  var lastInput = {};
+  var hostCaps = {};
+  var openai = window.openai;
+
+  // ---- JSON-RPC over postMessage (MCP Apps) ----
+  function post(msg) { window.parent.postMessage(msg, "*"); }
+  function request(method, params) {
+    var id = nextId++;
+    return new Promise(function (resolve, reject) {
+      pending[id] = { resolve: resolve, reject: reject };
+      post({ jsonrpc: "2.0", id: id, method: method, params: params || {} });
+    });
+  }
+  function notify(method, params) { post({ jsonrpc: "2.0", method: method, params: params || {} }); }
+
+  window.addEventListener("message", function (event) {
+    if (event.source !== window.parent) return;
+    var msg = event.data;
+    if (!msg || msg.jsonrpc !== "2.0") return;
+    if (msg.id !== undefined && !msg.method) {
+      var p = pending[msg.id];
+      if (!p) return;
+      delete pending[msg.id];
+      if (msg.error) p.reject(new Error(msg.error.message || "request failed"));
+      else p.resolve(msg.result);
+      return;
+    }
+    if (msg.method === "ui/notifications/tool-input") { lastInput = (msg.params && msg.params.arguments) || {}; return; }
+    if (msg.method === "ui/notifications/tool-result") { render(msg.params || {}); return; }
+    if (msg.method === "ui/notifications/tool-cancelled") { message("The tool call was cancelled."); return; }
+    if (msg.method === "ui/notifications/host-context-changed") { applyContext(msg.params || {}); return; }
+    if (msg.method === "ui/resource-teardown") { post({ jsonrpc: "2.0", id: msg.id, result: {} }); return; }
+    if (msg.method === "ping" && msg.id !== undefined) { post({ jsonrpc: "2.0", id: msg.id, result: {} }); }
+  });
+
+  function applyContext(ctx) {
+    if (ctx.theme === "dark" || ctx.theme === "light") document.documentElement.setAttribute("data-theme", ctx.theme);
+    var vars = ctx.styles && ctx.styles.variables;
+    if (vars) Object.keys(vars).forEach(function (k) { if (vars[k]) document.documentElement.style.setProperty(k, vars[k]); });
+  }
+
+  function callTool(name, args) {
+    if (openai && typeof openai.callTool === "function") return openai.callTool(name, args);
+    return request("tools/call", { name: name, arguments: args || {} });
+  }
+  function canCallTools() { return !!(openai && openai.callTool) || !!hostCaps.serverTools; }
+  function sendMessage(text) {
+    if (openai && typeof openai.sendFollowUpMessage === "function") return openai.sendFollowUpMessage({ prompt: text });
+    return request("ui/message", { role: "user", content: [{ type: "text", text: text }] });
+  }
+  function canMessage() { return !!(openai && openai.sendFollowUpMessage) || !!hostCaps.message; }
+
+  // ---- DOM helpers (textContent only) ----
+  function el(tag, cls, text) {
+    var node = document.createElement(tag);
+    if (cls) node.className = cls;
+    if (text !== undefined && text !== null) node.textContent = String(text);
+    return node;
+  }
+  function clear() { while (root.firstChild) root.removeChild(root.firstChild); }
+  function message(text) { clear(); root.appendChild(el("p", "muted", text)); }
+  function where(f) { return f.file + (f.line ? ":" + f.line : ""); }
+  function duration(ms) {
+    if (typeof ms !== "number") return "";
+    if (ms < 1000) return Math.round(ms) + " ms";
+    var s = ms / 1000;
+    return s < 60 ? s.toFixed(1) + " s" : Math.floor(s / 60) + "m " + Math.round(s % 60) + "s";
+  }
+  function button(label, cls, onClick) {
+    var b = el("button", "act" + (cls ? " " + cls : ""), label);
+    b.type = "button";
+    b.addEventListener("click", function () {
+      if (b.disabled) return;
+      b.disabled = true;
+      var before = b.textContent;
+      b.textContent = "…";
+      Promise.resolve().then(onClick).catch(function (err) {
+        b.title = String(err && err.message || err);
+      }).then(function () { b.disabled = false; b.textContent = before; });
+    });
+    return b;
+  }
+
+  // ---- views ----
+  function render(result) {
+    var data = result.structuredContent;
+    if (!data && result.content) {
+      // Hosts that drop structuredContent: show the Markdown text.
+      clear();
+      var text = result.content.filter(function (c) { return c.type === "text"; }).map(function (c) { return c.text; }).join("\n\n");
+      root.appendChild(el("pre", null, text || "No result."));
+      return;
+    }
+    data = data || {};
+    if (data.error) return renderError(data.error);
+    if (data.run) return renderRun(data);
+    if (data.failure) return renderSingleFailure(data);
+    if (data.status === "running" && data.runId) return renderRunning(data);
+    message(data.ok ? "Done." : "The tool reported a problem; see the text reply.");
+  }
+
+  function renderError(error) {
+    clear();
+    var h = el("h1", null, "Could not run the tests");
+    h.appendChild(el("span", "badge bad", error.kind || "ERROR"));
+    root.appendChild(h);
+    root.appendChild(el("pre", null, error.message || ""));
+    if (error.hint) root.appendChild(el("p", "muted", error.hint));
+  }
+
+  function renderRunning(data) {
+    clear();
+    var h = el("h1", null, "Tests are running");
+    h.appendChild(el("span", "badge warn", data.runId));
+    root.appendChild(h);
+    var p = el("p", "muted");
+    p.appendChild(el("span", "spin"));
+    p.appendChild(document.createTextNode(" This report updates when the run finishes."));
+    root.appendChild(p);
+    if (!canCallTools()) return;
+    var poll = function () {
+      callTool("get-run-status", { runId: data.runId, waitSeconds: 20 }).then(function (res) {
+        var sc = (res && res.structuredContent) || {};
+        if (sc.status === "running" && !sc.run) setTimeout(poll, 500);
+        else render(res);
+      }).catch(function () { setTimeout(poll, 5000); });
+    };
+    setTimeout(poll, 500);
+  }
+
+  function renderRun(data) {
+    var run = data.run;
+    clear();
+    var total = run.passed + run.failed + run.flaky + run.skipped;
+    var h = el("h1", null, "Playwright test report");
+    var verdict = run.failed > 0 ? ["bad", run.failed + " failed"] : run.flaky > 0 ? ["warn", "flaky"] : total === 0 ? ["warn", "no tests ran"] : ["ok", "all passed"];
+    h.appendChild(el("span", "badge " + verdict[0], verdict[1]));
+    if (run.partial) h.appendChild(el("span", "badge warn", "stopped early"));
+    if (data.status === "cancelled") h.appendChild(el("span", "badge warn", "cancelled"));
+    root.appendChild(h);
+
+    var stats = el("div", "stats");
+    [["passed", run.passed], ["failed", run.failed], ["flaky", run.flaky], ["skipped", run.skipped]].forEach(function (s) {
+      var box = el("div", "stat " + s[0]);
+      box.appendChild(el("b", null, s[1]));
+      box.appendChild(el("span", null, s[0]));
+      stats.appendChild(box);
+    });
+    var time = el("div", "stat");
+    time.appendChild(el("b", null, duration(run.durationMs)));
+    time.appendChild(el("span", null, "duration"));
+    stats.appendChild(time);
+    root.appendChild(stats);
+
+    if (total > 0) {
+      var bar = el("div", "bar");
+      bar.setAttribute("role", "img");
+      bar.setAttribute("aria-label", run.passed + " passed, " + run.failed + " failed, " + run.flaky + " flaky, " + run.skipped + " skipped");
+      [["passed", "var(--ok)"], ["failed", "var(--bad)"], ["flaky", "var(--warn)"], ["skipped", "var(--line)"]].forEach(function (s) {
+        if (!run[s[0]]) return;
+        var seg = el("i");
+        seg.style.width = (100 * run[s[0]] / total) + "%";
+        seg.style.background = s[1];
+        bar.appendChild(seg);
+      });
+      root.appendChild(bar);
+    }
+
+    if (!run.failures.length) {
+      root.appendChild(el("div", "empty", run.failed > 0 ? "Failures were not listed. Ask for get-failure." : "No failures."));
+    } else {
+      var toolbar = el("div", "toolbar");
+      var search = el("input");
+      search.type = "search";
+      search.placeholder = "Filter failures by title, file or error";
+      search.setAttribute("aria-label", "Filter failures");
+      toolbar.appendChild(search);
+      if (run.failures.length > 1 && canMessage()) {
+        toolbar.appendChild(button("Fix all", "primary", function () {
+          return sendMessage("Please fix the " + run.failures.length + " failing Playwright tests from the last run. Start with get-failure for each one, then suggest-fix.");
+        }));
+      }
+      root.appendChild(toolbar);
+      var list = el("ul");
+      run.failures.forEach(function (f, i) { list.appendChild(failureItem(f, i + 1, run.failures.length === 1)); });
+      root.appendChild(list);
+      search.addEventListener("input", function () {
+        var q = search.value.trim().toLowerCase();
+        Array.prototype.forEach.call(list.children, function (li) {
+          li.style.display = !q || li.getAttribute("data-text").indexOf(q) >= 0 ? "" : "none";
+        });
+      });
+      if (run.failuresTruncated) root.appendChild(el("p", "note", "Only the first failures are listed; the text reply has the rest."));
+    }
+    if (run.quarantined) root.appendChild(el("p", "note", run.quarantined + " failing test(s) are quarantined and do not fail the run."));
+    var rerun = rerunArgs();
+    if (rerun && canCallTools()) {
+      var actions = el("div", "actions");
+      actions.appendChild(button("Run again", null, function () {
+        message("Running the tests again…");
+        return callTool("run-test", rerun).then(render);
+      }));
+      root.appendChild(actions);
+    }
+  }
+
+  function rerunArgs() {
+    var keep = {};
+    ["testFiles", "grep", "browser", "config", "projectRoot", "retries", "workers", "lastFailed", "timeoutMs", "testTimeoutMs"].forEach(function (k) {
+      if (lastInput[k] !== undefined) keep[k] = lastInput[k];
+    });
+    return keep;
+  }
+
+  function failureItem(f, index, open) {
+    var li = el("li", "failure" + (open ? " open" : ""));
+    li.setAttribute("data-text", (f.title + " " + f.file + " " + f.message).toLowerCase());
+    var head = el("button", "head");
+    head.type = "button";
+    head.setAttribute("aria-expanded", open ? "true" : "false");
+    var t = el("div", "title", f.title);
+    t.appendChild(el("span", "kind", f.kind));
+    head.appendChild(t);
+    head.appendChild(el("div", "where", where(f) + (f.project ? "  ·  " + f.project : "")));
+    li.appendChild(head);
+    var body = el("div", "body");
+    body.appendChild(el("pre", null, f.message));
+    var details = el("div");
+    body.appendChild(details);
+    var actions = el("div", "actions");
+    if (canCallTools()) {
+      actions.appendChild(button("Show details", null, function () {
+        return callTool("get-failure", { index: index }).then(function (res) {
+          var sc = (res && res.structuredContent) || {};
+          while (details.firstChild) details.removeChild(details.firstChild);
+          fillDetails(details, sc.failure, res);
+        });
+      }));
+      actions.appendChild(button("Re-run this test", null, function () {
+        message("Running " + where(f) + "…");
+        return callTool("run-test", { testFiles: [where(f)] }).then(render);
+      }));
+    }
+    if (canMessage()) {
+      actions.appendChild(button("Ask to fix", "primary", function () {
+        return sendMessage("Fix the failing Playwright test \"" + f.title + "\" at " + where(f) + ". Call get-failure with index " + index + " first, then suggest-fix.");
+      }));
+    }
+    if (actions.firstChild) body.appendChild(actions);
+    li.appendChild(body);
+    head.addEventListener("click", function () {
+      var isOpen = li.classList.toggle("open");
+      head.setAttribute("aria-expanded", isOpen ? "true" : "false");
+    });
+    return li;
+  }
+
+  function fillDetails(target, failure, res) {
+    if (failure && (failure.expected || failure.actual)) {
+      var cmp = el("div", "cmp");
+      var a = el("div"); a.appendChild(el("span", null, "Expected")); a.appendChild(el("pre", null, failure.expected || ""));
+      var b = el("div"); b.appendChild(el("span", null, "Received")); b.appendChild(el("pre", null, failure.actual || ""));
+      cmp.appendChild(a); cmp.appendChild(b);
+      target.appendChild(cmp);
+    }
+    var text = ((res && res.content) || []).filter(function (c) { return c.type === "text"; }).map(function (c) { return c.text; }).join("\n\n");
+    if (text) target.appendChild(el("pre", null, text));
+  }
+
+  function renderSingleFailure(data) {
+    clear();
+    var f = data.failure;
+    var h = el("h1", null, "Failure " + (data.index || 1) + (data.total ? " of " + data.total : ""));
+    h.appendChild(el("span", "badge bad", f.kind));
+    root.appendChild(h);
+    root.appendChild(el("div", "title", f.title));
+    root.appendChild(el("div", "where", where(f)));
+    var box = el("div");
+    box.appendChild(el("pre", null, f.message));
+    fillDetails(box, { expected: f.expected, actual: f.actual }, null);
+    root.appendChild(box);
+    var actions = el("div", "actions");
+    if (canCallTools() && data.total && data.total > 1) {
+      var i = data.index || 1;
+      if (i > 1) actions.appendChild(button("Previous", null, function () { return callTool("get-failure", { index: i - 1 }).then(render); }));
+      if (i < data.total) actions.appendChild(button("Next", null, function () { return callTool("get-failure", { index: i + 1 }).then(render); }));
+    }
+    if (canMessage()) {
+      actions.appendChild(button("Ask to fix", "primary", function () {
+        return sendMessage("Fix the failing Playwright test \"" + f.title + "\" at " + where(f) + " with suggest-fix.");
+      }));
+    }
+    if (actions.firstChild) root.appendChild(actions);
+  }
+
+  // ---- size reporting ----
+  function reportSize() {
+    var h = Math.ceil(document.documentElement.getBoundingClientRect().height);
+    notify("ui/notifications/size-changed", { width: Math.ceil(window.innerWidth), height: h });
+  }
+
+  // ---- start ----
+  if (openai) {
+    // ChatGPT's window.openai bridge: the result is already there.
+    if (openai.toolInput) lastInput = openai.toolInput;
+    if (openai.toolOutput) render({ structuredContent: openai.toolOutput });
+    window.addEventListener("openai:set_globals", function () {
+      if (window.openai.toolOutput) render({ structuredContent: window.openai.toolOutput });
+    });
+    return;
+  }
+  request("ui/initialize", {
+    appInfo: { name: "playwright-e2e-mcp-report", version: "1.0.0" },
+    appCapabilities: {},
+    protocolVersion: "2026-01-26"
+  }).then(function (init) {
+    hostCaps = (init && init.hostCapabilities) || {};
+    applyContext((init && init.hostContext) || {});
+    notify("ui/notifications/initialized", {});
+    if (typeof ResizeObserver === "function") new ResizeObserver(reportSize).observe(document.body);
+    reportSize();
+  }).catch(function () { /* not inside an MCP Apps host */ });
+})();
+</script>
+</body>
+</html>
+`;
+//# sourceMappingURL=test-report-html.js.map

package/dist/apps/test-report-html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-report-html.js","sourceRoot":"","sources":["../../src/apps/test-report-html.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8ZzC,CAAC"}