@testdriverai/mcp 7.9.150-test → 7.9.152-test

package/docs/v7/quickstart.mdx

@@ -10,6 +10,53 @@ TestDriver makes it easy to write automated computer-use tests for web browsers,
 <Tip><a href="https://discord.com/invite/cWDFW8DzPm" target="_blank" rel="noreferrer">Join our Discord</a> if you have any questions or need help getting started!</Tip>
 
 <Tabs>
+  <Tab title="Add to GitHub" icon="github">
+
+    Drop-in UI testing for any GitHub repository. Mention `@testdriverai` anywhere in your repo and it writes UI tests and catches regressions before they merge.
+
+    <Card
+      title="Add to GitHub"
+      icon="github"
+      href="https://go.testdriver.ai/github"
+      arrow
+      horizontal
+    >
+      Install the TestDriver GitHub app and start testing in minutes — no setup required.
+    </Card>
+
+    <Steps>
+      <Step title="Install the GitHub App">
+        Click **Add to GitHub** above and install TestDriver on the repositories you want to test.
+      </Step>
+
+      <Step title="Mention @testdriverai">
+        Open a pull request or issue and mention `@testdriverai` to have it write and run UI tests:
+
+        ```
+        @testdriverai Write a test that verifies the homepage loads and the signup button works.
+        ```
+
+        TestDriver spawns a sandbox, writes the test, and posts results right in the conversation.
+      </Step>
+
+      <Step title="Catch Regressions Automatically">
+        Once your tests are committed, TestDriver runs them on every pull request and flags regressions before they merge.
+      </Step>
+    </Steps>
+
+    Want to use TestDriver from GitHub Copilot or the GitHub Mobile app instead? See the full GitHub guide:
+
+    <Card
+      title="GitHub Integration Guide"
+      icon="arrow-right"
+      href="/v7/copilot/auto-healing#use-testdriver-in-github"
+      arrow
+      horizontal
+    >
+      Use TestDriver from GitHub web, Copilot chat, PR reviews, and mobile.
+    </Card>
+
+  </Tab>
   <Tab title="CLI" icon="terminal">
 
     Get started quickly with the TestDriver CLI.
@@ -40,32 +87,263 @@ TestDriver makes it easy to write automated computer-use tests for web browsers,
       </Step>
     </Steps>
   </Tab>
-  <Tab title="GitHub Copilot" icon="github">
+  <Tab title="AI Setup" icon="robot">
 
-    Use the TestDriver VS Code extension with GitHub Copilot for an AI-powered testing workflow.
+    Plug TestDriver into your AI client so you can write, run, and debug real end-to-end tests right from chat. There are three pieces, and `testdriverai init` installs all of them for you:
 
-    <Card
-      title="Install TestDriver for VS Code"
-      icon="/images/content/extension/vscode.svg"
-      href="vscode:extension/testdriver.testdriver"
-      arrow
-      horizontal
-    >
-    </Card>
+    - **The agent** — an expert test-creator that drives a live sandbox, writes code after each step, and reruns the test until it passes.
+    - **Skills** — small instruction files that teach the agent the exact syntax for each TestDriver capability (`find`, `click`, `type`, `assert`, …).
+    - **The MCP server** — exposes TestDriver's computer-use tools over the [Model Context Protocol](https://modelcontextprotocol.io) so any MCP-capable client can use them.
 
-    The extension provides one-click sign-in, project initialization, a live preview panel for watching tests execute, and MCP server configuration for GitHub Copilot.
+    ### Quick install (recommended)
 
-    Once installed, follow the full setup guide to configure MCP and start building tests with AI assistance:
+    `testdriverai init` wires up the agent, skills, and MCP server for you, writing each client's config in the exact format and location it expects:
 
-    <Card
-      title="VS Code + Copilot Setup Guide"
-      icon="arrow-right"
-      href="/v7/copilot/setup"
-      arrow
-      horizontal
-    >
-      Sign in, initialize your project, and configure MCP for GitHub Copilot.
-    </Card>
+    ```bash
+    # interactive — pick your client(s)
+    npx testdriverai init
+
+    # one client
+    npx testdriverai init --client claude-code
+
+    # several
+    npx testdriverai init --client claude-code,cursor,vscode
+
+    # everything
+    npx testdriverai init --client all
+    ```
+
+    <Info>
+    `init` detects clients already present in your project and pre-selects them in the picker. Re-running `init` is safe — it merges the TestDriver entry into existing config without overwriting your other servers.
+    </Info>
+
+    You'll need a TestDriver API key. Create one at [console.testdriver.ai/team](https://console.testdriver.ai/team) and `init` will save it to `.env` as `TD_API_KEY`.
+
+    ### The agent
+
+    The **TestDriver agent** is an expert test-creator that runs inside your AI client (Claude Code, Cursor, VS Code, and others). It writes, runs, and debugs real end-to-end tests by driving your app the same way a person would — using AI vision to find elements, click, type, and assert — through the TestDriver MCP server.
+
+    Unlike a chat assistant that only suggests code, the agent works **iteratively against a live sandbox**: it starts a session, performs each action, writes the generated code to your test file, verifies the result with a screenshot, and reruns the test until it passes.
+
+    During init you'll be asked which AI client(s) to install into. The agent is written to the location each client expects:
+
+    | Client | Agent location |
+    | --- | --- |
+    | Claude Code | `.claude/agents/testdriver.md` |
+    | VS Code (Copilot) | `.github/agents/testdriver.agent.md` |
+    | Cursor | `.cursor/rules/testdriver.mdc` |
+    | Windsurf | `.windsurf/rules/testdriver.md` |
+    | Codex | `AGENTS.md` |
+    | Zed | `.rules` |
+
+    Once installed, invoke it from your client's chat:
+
+    ```text
+    @testdriver write a test that logs in and verifies the dashboard loads
+    ```
+
+    The agent will spin up a sandbox, perform the steps live, write them into a test file under `tests/`, and run it for you.
+
+    ### Skills
+
+    **Skills** are small, focused instruction files — one per TestDriver capability — that teach your AI client exactly how to use each part of the TestDriver SDK and MCP tools. They follow the [Anthropic `SKILL.md` format](https://code.claude.com/docs/en/skills): a folder per skill, each containing a `SKILL.md` with YAML frontmatter and a markdown body.
+
+    There are **106 skills**, generated directly from the TestDriver documentation, covering every action and concept: `find`, `click`, `type`, `assert`, `check`, `scroll`, `press-keys`, `provision`, caching, secrets, CI/CD, and more. They're written to the directory each client expects:
+
+    | Client | Skills location |
+    | --- | --- |
+    | Claude Code | `.claude/skills/<name>/SKILL.md` |
+    | Zed | `.agents/skills/<name>/SKILL.md` |
+    | Codex | referenced from `AGENTS.md` |
+    | VS Code · Cursor · Windsurf | folded into the agent rules/instructions |
+
+    <Note>
+    Skills are **generated, not hand-edited** — each is built from a `.mdx` docs page and carries a `DO NOT EDIT` marker. To change a skill, edit the corresponding documentation page and run `node docs/_scripts/generate-skills.js`.
+    </Note>
+
+    ### MCP server
+
+    The **TestDriver MCP server** exposes TestDriver's computer-use tools — `session_start`, `find`, `click`, `type`, `assert`, `check`, `screenshot`, and more — over the [Model Context Protocol](https://modelcontextprotocol.io). It runs as a local stdio process:
+
+    ```bash
+    npx -p testdriverai testdriverai-mcp
+    ```
+
+    and authenticates with your `TD_API_KEY`. `testdriverai init` configures it for you, but you can also wire it up by hand:
+
+    | Client | Auto-install | MCP config file | Config key |
+    | --- | --- | --- | --- |
+    | Claude Code | ✅ | `.mcp.json` | `mcpServers` |
+    | Claude Desktop | ✅ | OS-specific | `mcpServers` |
+    | Cursor | ✅ | `.cursor/mcp.json` | `mcpServers` |
+    | VS Code (Copilot) | ✅ | `.vscode/mcp.json` | `servers` |
+    | Windsurf | ✅ | `~/.codeium/windsurf/mcp_config.json` | `mcpServers` |
+    | Codex | ✅ | `~/.codex/config.toml` | `[mcp_servers]` |
+    | Zed | ✅ | `.zed/settings.json` | `context_servers` |
+    | Lovable | ⚙️ partial | GitHub `AGENTS.md` + UI | — |
+    | Replit | ⚙️ partial | `replit.md` + UI | — |
+    | v0 (Vercel) | 📝 manual | web UI only | — |
+
+    <Note>
+    Each client uses a **different top-level key** for MCP servers. The most common mistake when configuring by hand is using `mcpServers` for VS Code (it wants `servers`), Codex (TOML `[mcp_servers]`), or Zed (`context_servers`).
+    </Note>
+
+    <Tabs>
+      <Tab title="Claude Code">
+        Add to `.mcp.json` at your project root (or `~/.claude.json` for all projects):
+
+        ```json
+        {
+          "mcpServers": {
+            "testdriver": {
+              "type": "stdio",
+              "command": "npx",
+              "args": ["-p", "testdriverai", "testdriverai-mcp"],
+              "env": { "TD_API_KEY": "${TD_API_KEY}" }
+            }
+          }
+        }
+        ```
+      </Tab>
+
+      <Tab title="Claude Desktop">
+        Edit the Claude Desktop config file:
+
+        - **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+        - **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+        - **Linux:** `~/.config/Claude/claude_desktop_config.json`
+
+        ```json
+        {
+          "mcpServers": {
+            "testdriver": {
+              "command": "npx",
+              "args": ["-p", "testdriverai", "testdriverai-mcp"],
+              "env": { "TD_API_KEY": "your_api_key" }
+            }
+          }
+        }
+        ```
+
+        Restart Claude Desktop after saving.
+      </Tab>
+
+      <Tab title="Cursor">
+        Add to `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (global):
+
+        ```json
+        {
+          "mcpServers": {
+            "testdriver": {
+              "type": "stdio",
+              "command": "npx",
+              "args": ["-p", "testdriverai", "testdriverai-mcp"],
+              "env": { "TD_API_KEY": "${TD_API_KEY}" }
+            }
+          }
+        }
+        ```
+      </Tab>
+
+      <Tab title="VS Code">
+        Add to `.vscode/mcp.json`. VS Code uses the `servers` key and an `inputs` prompt for secrets:
+
+        ```json
+        {
+          "servers": {
+            "testdriver": {
+              "type": "stdio",
+              "command": "npx",
+              "args": ["-p", "testdriverai", "testdriverai-mcp"],
+              "env": { "TD_API_KEY": "${input:testdriver-api-key}" }
+            }
+          },
+          "inputs": [
+            {
+              "type": "promptString",
+              "id": "testdriver-api-key",
+              "description": "TestDriver API Key From https://console.testdriver.ai/team",
+              "password": true
+            }
+          ]
+        }
+        ```
+      </Tab>
+
+      <Tab title="Windsurf">
+        Windsurf reads MCP config globally. Add to `~/.codeium/windsurf/mcp_config.json`:
+
+        ```json
+        {
+          "mcpServers": {
+            "testdriver": {
+              "command": "npx",
+              "args": ["-p", "testdriverai", "testdriverai-mcp"],
+              "env": { "TD_API_KEY": "${TD_API_KEY}" }
+            }
+          }
+        }
+        ```
+      </Tab>
+
+      <Tab title="Codex">
+        Codex uses TOML. Add to `~/.codex/config.toml`:
+
+        ```toml
+        [mcp_servers.testdriver]
+        command = "npx"
+        args = ["-p", "testdriverai", "testdriverai-mcp"]
+        env = { TD_API_KEY = "${TD_API_KEY}" }
+        ```
+      </Tab>
+
+      <Tab title="Zed">
+        Zed calls them "context servers". Add to `.zed/settings.json` (project) or `~/.config/zed/settings.json` (global):
+
+        ```json
+        {
+          "context_servers": {
+            "testdriver": {
+              "command": "npx",
+              "args": ["-p", "testdriverai", "testdriverai-mcp"],
+              "env": { "TD_API_KEY": "${TD_API_KEY}" }
+            }
+          }
+        }
+        ```
+      </Tab>
+    </Tabs>
+
+    **Web-based clients** — Lovable, Replit, and v0 run in the browser, so the MCP server can't be launched as a local process. Configure them through each product's UI:
+
+    <AccordionGroup>
+      <Accordion title="Lovable">
+        1. Connect your GitHub repo and run `npx testdriverai init --client lovable` — this writes `AGENTS.md` and the skills into the repo so Lovable's agent picks them up.
+        2. In Lovable, open **Settings → MCP** and add the TestDriver server.
+      </Accordion>
+
+      <Accordion title="Replit">
+        1. Run `npx testdriverai init --client replit` to write `replit.md` with the TestDriver agent guidance.
+        2. In Replit, open **Tools → Integrations → MCP** and add a custom MCP server.
+      </Accordion>
+
+      <Accordion title="v0 (Vercel)">
+        v0 is fully UI-driven and does not read repo files.
+
+        1. Open **[v0.app/chat/settings/mcp-connections](https://v0.app/chat/settings/mcp-connections)** and add the TestDriver MCP connection.
+        2. Paste the agent guidance into **Instructions** (the **+** in the prompt bar).
+      </Accordion>
+    </AccordionGroup>
+
+    ### Verifying the install
+
+    Open your client's chat and ask the agent to write a test:
+
+    ```text
+    @testdriver write a test that opens the homepage and asserts the title
+    ```
+
+    If the MCP server is wired up correctly, the agent will start a session and you'll see screenshots come back as it works. If tools don't appear, check that `TD_API_KEY` is set and restart the client.
 
   </Tab>
   <Tab title="Manual" icon="wrench">

package/docs/v7/wait.mdx

@@ -49,4 +49,4 @@ await testdriver.wait();
   const element = await testdriver.find('success message');
   ```
 - Avoid excessively long timeouts to keep tests efficient.
-- Use sparingly — TestDriver's [redraw detection](/v7/waiting-for-elements) automatically waits for screen and network stability after each action.
+- Use sparingly — TestDriver's [redraw detection](/v7/performing-actions#waiting-for-dynamic-content) automatically waits for screen and network stability after each action.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testdriverai/mcp",
-  "version": "7.9.150-test",
+  "version": "7.9.152-test",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",
@@ -48,8 +48,8 @@
     "start": "node bin/testdriverai.js",
     "dev": "DEV=true node bin/testdriverai.js",
     "debug": "DEV=true VERBOSE=true node bin/testdriverai.js",
-    "docs": "npm run docs:skills && cd docs && npx mint@latest dev --port 3002",
-    "docs:dev": "cd docs && npx mint dev --port 3002",
+    "docs": "npm run docs:skills && cd docs && npx mint@latest dev --port 3003",
+    "docs:dev": "cd docs && npx mint dev --port 3003",
     "docs:build": "npm run docs:skills && cd docs && npx mint@latest build",
     "docs:links": "node docs/_scripts/link-replacer.js",
     "docs:skills": "node docs/_scripts/generate-skills.js",

package/docs/v7/ai/agent.mdx

@@ -1,72 +0,0 @@
----
-title: "Agent"
-sidebarTitle: "Agent"
-description: "The TestDriver test-creator agent that writes and debugs end-to-end tests for you"
-icon: "robot"
----
-
-## Overview
-
-The **TestDriver agent** is an expert test-creator that runs inside your AI client (Claude Code, Cursor, VS Code, and others). It writes, runs, and debugs real end-to-end tests by driving your app the same way a person would — using AI vision to find elements, click, type, and assert — through the [TestDriver MCP Server](/v7/ai/mcp).
-
-Unlike a chat assistant that only suggests code, the agent works **iteratively against a live sandbox**: it starts a session, performs each action, writes the generated code to your test file, verifies the result with a screenshot, and reruns the test until it passes.
-
-## What it does
-
-- **Builds tests from scratch** using TestDriver [skills](/v7/ai/skills) and best practices.
-- **Drives a live sandbox** via MCP tools (`session_start`, `find`, `click`, `type`, `assert`, `check`, …), getting a screenshot and generated code after every action.
-- **Writes code immediately** to the test file after each successful step — never all at once at the end.
-- **Verifies visually** with `check` to confirm each action did what was intended.
-- **Runs the test itself** with `vitest run` and iterates until it passes reliably.
-- **Shares the run report** — after each run it surfaces the `TESTDRIVER_RUN_URL` so you can watch the recording.
-
-## Installation
-
-The agent is installed automatically by `testdriverai init`, alongside the [skills](/v7/ai/skills) and the [MCP server](/v7/ai/mcp):
-
-```bash
-npx testdriverai init
-```
-
-During init you'll be asked which AI client(s) to install into. The agent is written to the location each client expects:
-
-| Client | Agent location |
-| --- | --- |
-| Claude Code | `.claude/agents/testdriver.md` |
-| VS Code (Copilot) | `.github/agents/testdriver.agent.md` |
-| Cursor | `.cursor/rules/testdriver.mdc` |
-| Windsurf | `.windsurf/rules/testdriver.md` |
-| Codex | `AGENTS.md` |
-| Zed | `.rules` |
-
-To install for a specific client without the interactive picker:
-
-```bash
-npx testdriverai init --client claude-code
-# or several at once
-npx testdriverai init --client claude-code,cursor,vscode
-# or everything
-npx testdriverai init --client all
-```
-
-See the [MCP Server](/v7/ai/mcp) page for the full client matrix, including web-based clients (Lovable, Replit, v0) that require a few manual steps.
-
-## Prerequisites
-
-You need a TestDriver API key. Create one at [console.testdriver.ai/team](https://console.testdriver.ai/team) and `init` will save it to `.env` as `TD_API_KEY`.
-
-## Using the agent
-
-Once installed, invoke it from your client's chat:
-
-```text
-@testdriver write a test that logs in and verifies the dashboard loads
-```
-
-The agent will spin up a sandbox, perform the steps live, write them into a test file under `tests/`, and run it for you.
-
-## Related
-
-- [Skills](/v7/ai/skills) — the building blocks the agent composes tests from
-- [MCP Server](/v7/ai/mcp) — the tools the agent uses to drive your app
-- [Generating tests](/v7/generating-tests) — how test generation works end-to-end

package/docs/v7/ai/mcp.mdx

@@ -1,228 +0,0 @@
----
-title: "MCP Server"
-sidebarTitle: "MCP Server"
-description: "Install the TestDriver MCP server in any AI client — Claude Code, Cursor, VS Code, Windsurf, Codex, Zed, and more"
-icon: "plug"
----
-
-## Overview
-
-The **TestDriver MCP server** exposes TestDriver's computer-use tools — `session_start`, `find`, `click`, `type`, `assert`, `check`, `screenshot`, and more — over the [Model Context Protocol](https://modelcontextprotocol.io). Any MCP-capable AI client can use it to drive a live sandbox and write real end-to-end tests.
-
-It runs as a local stdio process:
-
-```bash
-npx -p testdriverai testdriverai-mcp
-```
-
-and authenticates with your `TD_API_KEY` (from [console.testdriver.ai/team](https://console.testdriver.ai/team)).
-
-## Quick install (recommended)
-
-`testdriverai init` wires up the MCP server, the [agent](/v7/ai/agent), and the [skills](/v7/ai/skills) for you, writing each client's config in the exact format and location it expects:
-
-```bash
-# interactive — pick your client(s)
-npx testdriverai init
-
-# one client
-npx testdriverai init --client claude-code
-
-# several
-npx testdriverai init --client claude-code,cursor,vscode
-
-# everything
-npx testdriverai init --client all
-```
-
-<Info>
-`init` detects clients already present in your project and pre-selects them in the picker. Re-running `init` is safe — it merges the TestDriver entry into existing config without overwriting your other servers.
-</Info>
-
-## Client support matrix
-
-| Client | Auto-install | MCP config file | Config key |
-| --- | --- | --- | --- |
-| Claude Code | ✅ | `.mcp.json` | `mcpServers` |
-| Claude Desktop | ✅ | OS-specific (see below) | `mcpServers` |
-| Cursor | ✅ | `.cursor/mcp.json` | `mcpServers` |
-| VS Code (Copilot) | ✅ | `.vscode/mcp.json` | `servers` |
-| Windsurf | ✅ | `~/.codeium/windsurf/mcp_config.json` | `mcpServers` |
-| Codex | ✅ | `~/.codex/config.toml` | `[mcp_servers]` |
-| Zed | ✅ | `.zed/settings.json` | `context_servers` |
-| Lovable | ⚙️ partial | GitHub `AGENTS.md` + UI | — |
-| Replit | ⚙️ partial | `replit.md` + UI | — |
-| v0 (Vercel) | 📝 manual | web UI only | — |
-
-<Note>
-Each client uses a **different top-level key** for MCP servers. The most common mistake when configuring by hand is using `mcpServers` for VS Code (it wants `servers`), Codex (TOML `[mcp_servers]`), or Zed (`context_servers`).
-</Note>
-
-## Manual installation
-
-If you'd rather configure by hand, use the snippets below. The stdio command is the same everywhere; only the wrapper key and file location change.
-
-<Tabs>
-  <Tab title="Claude Code">
-    Add to `.mcp.json` at your project root (or `~/.claude.json` for all projects):
-
-    ```json
-    {
-      "mcpServers": {
-        "testdriver": {
-          "type": "stdio",
-          "command": "npx",
-          "args": ["-p", "testdriverai", "testdriverai-mcp"],
-          "env": { "TD_API_KEY": "${TD_API_KEY}" }
-        }
-      }
-    }
-    ```
-  </Tab>
-
-  <Tab title="Claude Desktop">
-    Edit the Claude Desktop config file:
-
-    - **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
-    - **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
-    - **Linux:** `~/.config/Claude/claude_desktop_config.json`
-
-    ```json
-    {
-      "mcpServers": {
-        "testdriver": {
-          "command": "npx",
-          "args": ["-p", "testdriverai", "testdriverai-mcp"],
-          "env": { "TD_API_KEY": "your_api_key" }
-        }
-      }
-    }
-    ```
-
-    Restart Claude Desktop after saving.
-  </Tab>
-
-  <Tab title="Cursor">
-    Add to `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (global):
-
-    ```json
-    {
-      "mcpServers": {
-        "testdriver": {
-          "type": "stdio",
-          "command": "npx",
-          "args": ["-p", "testdriverai", "testdriverai-mcp"],
-          "env": { "TD_API_KEY": "${TD_API_KEY}" }
-        }
-      }
-    }
-    ```
-  </Tab>
-
-  <Tab title="VS Code">
-    Add to `.vscode/mcp.json`. VS Code uses the `servers` key and an `inputs` prompt for secrets:
-
-    ```json
-    {
-      "servers": {
-        "testdriver": {
-          "type": "stdio",
-          "command": "npx",
-          "args": ["-p", "testdriverai", "testdriverai-mcp"],
-          "env": { "TD_API_KEY": "${input:testdriver-api-key}" }
-        }
-      },
-      "inputs": [
-        {
-          "type": "promptString",
-          "id": "testdriver-api-key",
-          "description": "TestDriver API Key From https://console.testdriver.ai/team",
-          "password": true
-        }
-      ]
-    }
-    ```
-  </Tab>
-
-  <Tab title="Windsurf">
-    Windsurf reads MCP config globally. Add to `~/.codeium/windsurf/mcp_config.json`:
-
-    ```json
-    {
-      "mcpServers": {
-        "testdriver": {
-          "command": "npx",
-          "args": ["-p", "testdriverai", "testdriverai-mcp"],
-          "env": { "TD_API_KEY": "${TD_API_KEY}" }
-        }
-      }
-    }
-    ```
-  </Tab>
-
-  <Tab title="Codex">
-    Codex uses TOML. Add to `~/.codex/config.toml`:
-
-    ```toml
-    [mcp_servers.testdriver]
-    command = "npx"
-    args = ["-p", "testdriverai", "testdriverai-mcp"]
-    env = { TD_API_KEY = "${TD_API_KEY}" }
-    ```
-  </Tab>
-
-  <Tab title="Zed">
-    Zed calls them "context servers". Add to `.zed/settings.json` (project) or `~/.config/zed/settings.json` (global):
-
-    ```json
-    {
-      "context_servers": {
-        "testdriver": {
-          "command": "npx",
-          "args": ["-p", "testdriverai", "testdriverai-mcp"],
-          "env": { "TD_API_KEY": "${TD_API_KEY}" }
-        }
-      }
-    }
-    ```
-  </Tab>
-</Tabs>
-
-## Web-based clients
-
-Lovable, Replit, and v0 run in the browser, so the MCP server can't be launched as a local process. Configure them through each product's UI.
-
-<AccordionGroup>
-  <Accordion title="Lovable">
-    1. Connect your GitHub repo and run `npx testdriverai init --client lovable` — this writes `AGENTS.md` and the skills into the repo so Lovable's agent picks them up.
-    2. In Lovable, open **Settings → MCP** and add the TestDriver server.
-  </Accordion>
-
-  <Accordion title="Replit">
-    1. Run `npx testdriverai init --client replit` to write `replit.md` with the TestDriver agent guidance.
-    2. In Replit, open **Tools → Integrations → MCP** and add a custom MCP server.
-  </Accordion>
-
-  <Accordion title="v0 (Vercel)">
-    v0 is fully UI-driven and does not read repo files.
-
-    1. Open **[v0.app/chat/settings/mcp-connections](https://v0.app/chat/settings/mcp-connections)** and add the TestDriver MCP connection.
-    2. Paste the agent guidance into **Instructions** (the **+** in the prompt bar).
-  </Accordion>
-</AccordionGroup>
-
-## Verifying the install
-
-After installing, open your client's chat and ask the agent to write a test:
-
-```text
-@testdriver write a test that opens the homepage and asserts the title
-```
-
-If the MCP server is wired up correctly, the agent will start a session and you'll see screenshots come back as it works. If tools don't appear, check that `TD_API_KEY` is set and restart the client.
-
-## Related
-
-- [Agent](/v7/ai/agent) — the test-creator that uses these tools
-- [Skills](/v7/ai/skills) — instruction files describing each tool
-- [CI/CD](/v7/ci-cd) — running the generated tests in your pipeline