@testdriverai/mcp 7.9.149-test → 7.9.151-test

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

package/docs/v7/ai/skills.mdx

@@ -1,73 +0,0 @@
----
-title: "Skills"
-sidebarTitle: "Skills"
-description: "Composable instruction files that teach any AI client how to use TestDriver"
-icon: "puzzle-piece"
----
-
-## Overview
-
-**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.
-
-```text
-.claude/skills/
-├── testdriver-click/
-│   └── SKILL.md
-├── testdriver-find/
-│   └── SKILL.md
-├── testdriver-assert/
-│   └── SKILL.md
-└── … (103 more)
-```
-
-Each `SKILL.md` looks like:
-
-```markdown
----
-name: testdriver:click
-description: Click at specific coordinates or on elements
----
-
-## Element Click
-
-When called on an Element object, clicks on the located element.
-…
-```
-
-## Why skills
-
-The [agent](/v7/ai/agent) is general; skills are specific. When the agent needs to perform an action — say, locate an element — it pulls in the `testdriver:find` skill, which contains the exact syntax, options, return shape, and gotchas for that one method. This keeps the agent accurate without bloating its base prompt, and lets clients load only the skills relevant to the current step.
-
-## Installation
-
-Skills are installed by `testdriverai init` along with the [agent](/v7/ai/agent) and [MCP server](/v7/ai/mcp):
-
-```bash
-npx testdriverai init
-```
-
-They're written to the skills 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 |
-
-Clients without a native skills concept (Cursor, VS Code, Windsurf) still get the agent definition, which references the same guidance inline.
-
-## Authoring & regenerating
-
-Skills are **generated, not hand-edited** — each is built from a `.mdx` page in the docs. Do not edit `SKILL.md` files directly (they carry a `DO NOT EDIT` marker). To change a skill, edit the corresponding documentation page and regenerate:
-
-```bash
-node docs/_scripts/generate-skills.js
-```
-
-## Related
-
-- [Agent](/v7/ai/agent) — composes skills into working tests
-- [MCP Server](/v7/ai/mcp) — the tools the skills describe how to use

package/docs/v7/ai.mdx

@@ -1,205 +0,0 @@
----
-title: "ai()"
-sidebarTitle: "ai"
-description: "Execute natural language tasks using AI"
-icon: "wand-magic-sparkles"
----
-
-## Overview
-
-The `ai()` method allows you to execute complex tasks using natural language descriptions. TestDriver's AI will figure out the steps needed to accomplish the task.
-
-## Syntax
-
-```javascript
-await testdriver.ai(task, options)
-```
-
-## Parameters
-
-<ParamField path="task" type="string" required>
-  Natural language description of what to do
-</ParamField>
-
-<ParamField path="options" type="object">
-  Execution options
-  
-  <Expandable title="properties">
-    <ParamField path="validateAndLoop" type="boolean" default="false">
-      Whether to validate completion and retry if incomplete
-    </ParamField>
-  </Expandable>
-</ParamField>
-
-## Returns
-
-`Promise<string | void>` - Final AI response if `validateAndLoop` is true
-
-## Examples
-
-### Basic Usage
-
-```javascript
-// Simple task execution
-await testdriver.ai('Click the submit button');
-
-// Complex multi-step task
-await testdriver.ai('Fill out the contact form and submit it');
-
-// Navigation task
-await testdriver.ai('Go to the settings page and enable notifications');
-```
-
-### With Validation
-
-```javascript
-// AI will verify the task completed successfully
-const result = await testdriver.ai('Complete the checkout process', { 
-  validateAndLoop: true 
-});
-
-console.log('Task result:', result);
-```
-
-### Multi-Step Workflows
-
-```javascript
-// The AI will break down complex tasks
-await testdriver.ai('Search for "laptop", add the first result to cart, and proceed to checkout');
-
-// UI exploration
-await testdriver.ai('Find and click all menu items to explore the application');
-```
-
-## Use Cases
-
-<AccordionGroup>
-  <Accordion title="Exploratory Testing">
-    Use AI to explore unfamiliar applications:
-    
-    ```javascript
-    await testdriver.ai('Explore the main navigation menu');
-    await testdriver.ai('Try to find the user profile settings');
-    ```
-  </Accordion>
-  
-  <Accordion title="Complex Workflows">
-    Let AI handle multi-step processes:
-    
-    ```javascript
-    await testdriver.ai('Complete the multi-step registration form');
-    await testdriver.ai('Configure all the advanced settings to default values');
-    ```
-  </Accordion>
-  
-  <Accordion title="Flexible Interactions">
-    When exact element locations aren't critical:
-    
-    ```javascript
-    await testdriver.ai('Close any popup dialogs');
-    await testdriver.ai('Accept the cookie consent if it appears');
-    ```
-  </Accordion>
-</AccordionGroup>
-
-## Best Practices
-
-<Check>
-  **Be specific but flexible**: Give enough context without over-constraining the AI
-  
-  ```javascript
-  // ✅ Good
-  await testdriver.ai('Add the first product to the shopping cart');
-  
-  // ❌ Too vague
-  await testdriver.ai('do something');
-  
-  // ❌ Too specific (defeats the purpose)
-  await testdriver.ai('click at coordinates 500, 300');
-  ```
-</Check>
-
-<Check>
-  **Use for exploration, not precision**: For critical assertions, use explicit methods
-  
-  ```javascript
-  // Use AI for setup
-  await testdriver.ai('Navigate to the login page');
-  
-  // Use explicit methods for critical steps
-  const usernameField = await testdriver.find('username input');
-  await usernameField.click();
-  await testdriver.type('testuser');
-  
-  await testdriver.assert('login page is displayed');
-  ```
-</Check>
-
-<Warning>
-  **AI tasks may be slower**: The AI needs to analyze the screen and plan actions. For performance-critical tests, use explicit methods.
-</Warning>
-
-## When to Use AI vs Explicit Methods
-
-### Use `ai()` when:
-- Exploring unfamiliar applications
-- Handling optional UI elements (popups, cookies, etc.)
-- Prototyping tests quickly
-- Tasks where exact steps may vary
-
-### Use explicit methods when:
-- Performance is critical
-- You need precise control
-- Making assertions
-- Debugging test failures
-- Repetitive, predictable actions
-
-## Complete Example
-
-```javascript
-import { beforeAll, afterAll, describe, it } from 'vitest';
-import TestDriver from 'testdriverai';
-
-describe('E-commerce Flow with AI', () => {
-  let testdriver;
-
-  beforeAll(async () => {
-    client = new TestDriver(process.env.TD_API_KEY);
-    await testdriver.auth();
-    await testdriver.connect();
-  });
-
-  afterAll(async () => {
-    await testdriver.disconnect();
-  });
-
-  it('should complete shopping flow using AI assistance', async () => {
-    await testdriver.focusApplication('Google Chrome');
-    
-    // Use AI for navigation and exploration
-    await testdriver.ai('Browse to the electronics section');
-    await testdriver.ai('Find and add a laptop to the cart');
-    
-    // Use explicit methods for critical steps
-    const cartIcon = await testdriver.find('shopping cart icon');
-    await cartIcon.click();
-    
-    const total = await testdriver.extract('the cart total amount');
-    console.log('Cart total:', total);
-    
-    // Use AI for checkout flow
-    await testdriver.ai('Proceed to checkout and fill in shipping details', {
-      validateAndLoop: true
-    });
-    
-    // Explicit assertion
-    await testdriver.assert('order confirmation page is displayed');
-  });
-});
-```
-
-## Related Methods
-
-- [`find()`](/v7/find) - Locate specific elements
-- [`assert()`](/v7/assert) - Make assertions
-- [`extract()`](/v7/extract) - Extract information

package/docs/v7/copilot/creating-tests.mdx

@@ -1,156 +0,0 @@
----
-title: "Creating Tests"
-sidebarTitle: "Creating Tests"
-description: "Use the TestDriver agent and MCP to create tests through natural language"
-icon: "wand-magic-sparkles"
----
-
-With GitHub Copilot and TestDriver's MCP server, you can create tests by chatting with an AI agent. The agent spawns a virtual machine, executes actions, and writes test code for you.
-
-## Start a Conversation
-
-Open GitHub Copilot Chat in VS Code. If your project has no other agents configured, the TestDriver agent is used by default. Otherwise, select **testdriver** from the agent dropdown in the chat panel.
-
-Describe what you want to test:
-
-```
-Create a test that logs into my app at https://myapp.com
-```
-
-The agent will:
-1. Start a new session and spawn a Linux virtual machine
-2. Launch Chrome and navigate to your URL
-3. Execute actions based on your instructions
-4. Write the test code to a `.test.mjs` file
-
-<Note>
-  The TestDriver agent appears in the agent selection dropdown if you have other agents configured (like `copilot-instructions.md` or other `.agent.md` files). Make sure to select **testdriver** to use TestDriver's MCP tools.
-</Note>
-
-## Live Preview Panel
-
-When the agent starts a session, a **live preview panel** opens in VS Code. This lets you:
-
-- **Watch tests execute** in real-time
-- **Interact with the VM** — click, type, and navigate manually
-- **Debug issues** — see exactly what the AI sees
-
-<Note>
-  The live preview panel requires the TestDriver VS Code extension. Set `TD_PREVIEW=ide` in your MCP configuration to enable it. See the [device configuration docs](/v7/device-config) for all preview options.
-</Note>
-
-## Interactive Workflow
-
-The recommended workflow for creating tests:
-
-<Steps>
-  <Step title="Describe Your Test">
-    Tell the agent what you want to test:
-
-    ```
-    Test the checkout flow on https://shop.example.com
-    ```
-  </Step>
-
-  <Step title="Watch and Guide">
-    The agent will start executing. Watch the preview panel and provide guidance if needed:
-
-    ```
-    The login modal appeared. Use test@example.com and password123
-    ```
-  </Step>
-
-  <Step title="Add Assertions">
-    Ask the agent to verify specific conditions:
-
-    ```
-    Assert that the order confirmation page is shown with the order number
-    ```
-  </Step>
-
-  <Step title="Review the Code">
-    The agent writes test code as it works. Review the generated `.test.mjs` file and make any adjustments.
-  </Step>
-</Steps>
-
-## Example Conversation
-
-Here's a complete example of creating a login test:
-
-```
-You: Create a test for the login flow at https://console.testdriver.ai
-
-Agent: I'll create a test for the login flow. Starting a session...
-       [Screenshot: Login page loaded]
-
-       I can see the login page. Let me find the email input.
-       [Screenshot: Email input highlighted]
-
-       Now I'll type the email and find the password field...
-
-You: Use test@example.com for the email
-
-Agent: Got it. Typing test@example.com...
-       [Screenshot: Email entered]
-
-       Now entering the password and clicking Sign In...
-       [Screenshot: Dashboard loaded]
-
-       ✅ Login successful! I've written the test to tests/login.test.mjs
-```
-
-## Generated Test Code
-
-The agent generates standard Vitest test files:
-
-```javascript tests/login.test.mjs
-import { describe, expect, it } from "vitest";
-import { TestDriver } from "testdriverai/vitest/hooks";
-
-describe("Login Flow", () => {
-  it("should log in successfully", async (context) => {
-    const testdriver = TestDriver(context);
-
-    await testdriver.provision.chrome({
-      url: "https://console.testdriver.ai"
-    });
-
-    const emailInput = await testdriver.find("email input field");
-    await emailInput.click();
-    await testdriver.type("test@example.com");
-
-    const passwordInput = await testdriver.find("password input field");
-    await passwordInput.click();
-    await testdriver.type("password123");
-
-    const signInButton = await testdriver.find("Sign In button");
-    await signInButton.click();
-
-    const result = await testdriver.assert("dashboard is visible");
-    expect(result).toBeTruthy();
-  });
-});
-```
-
-## Tips for Better Tests
-
-<AccordionGroup>
-  <Accordion title="Be specific with element descriptions">
-    Instead of "click the button", say "click the blue Sign In button in the header". More context helps the AI find the right element.
-  </Accordion>
-  <Accordion title="Add waits for dynamic content">
-    If your app has animations or loading states, tell the agent to wait:
-    ```
-    Wait for the loading spinner to disappear before continuing
-    ```
-  </Accordion>
-  <Accordion title="Use assertions liberally">
-    Add assertions after each major action to catch regressions early:
-    ```
-    Assert that the product was added to the cart
-    ```
-  </Accordion>
-  <Accordion title="Break complex flows into steps">
-    For long workflows, create the test incrementally and verify each step works before moving on.
-  </Accordion>
-</AccordionGroup>