@testdriverai/mcp 7.9.150-test → 7.9.152-test

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>

package/docs/v7/copilot/github.mdx

@@ -1,143 +0,0 @@
----
-title: "GitHub Integration"
-sidebarTitle: "GitHub"
-description: "Use TestDriver from GitHub's web interface and mobile app"
-icon: "github"
----
-
-TestDriver works directly in GitHub's web interface and mobile app. The same MCP server that powers VS Code integration also works in GitHub, letting you create and manage tests from anywhere.
-
-## How It Works
-
-When you add a TestDriver agent file to your repository at `.github/agents/testdriver.agent.md`, GitHub Copilot can use TestDriver's MCP tools directly in:
-
-- GitHub.com (web browser)
-- GitHub Mobile app (iOS/Android)
-- Pull request conversations
-- Issue comments
-
-## Using TestDriver in GitHub Web
-
-<Steps>
-  <Step title="Navigate to Your Repository">
-    Open your repository on GitHub.com. Make sure you have the TestDriver agent file at `.github/agents/testdriver.agent.md`.
-  </Step>
-
-  <Step title="Start a Copilot Chat">
-    Click the **Copilot icon** in the GitHub interface to open a chat. You can find this in:
-    - The repository's Code tab
-    - Pull request pages
-    - Issue pages
-  </Step>
-
-  <Step title="Invoke the TestDriver Agent">
-    Start your message with `@testdriver`:
-
-    ```
-    @testdriver Create a test that verifies the homepage loads correctly at https://myapp.com
-    ```
-
-    The agent will spawn a sandbox environment and begin executing, just like in VS Code.
-  </Step>
-
-  <Step title="View Screenshots in Chat">
-    As the test runs, screenshots appear directly in the chat. You can see what the AI sees and provide guidance if needed.
-  </Step>
-</Steps>
-
-## Creating Tests from PR Comments
-
-You can create tests directly from pull request reviews. Comment on a PR and mention Copilot:
-
-```
-@copilot create a TestDriver test that verifies this new feature works.
-Test the checkout flow with a guest user.
-```
-
-Copilot will:
-1. Use the TestDriver MCP server
-2. Create a test based on your description
-3. Commit the test file to the PR branch
-
-This is useful for:
-- Adding test coverage during code review
-- Verifying bug fixes before merging
-- Creating regression tests for new features
-
-## Creating Tests from Issues
-
-You can also create tests from issue comments:
-
-```
-@copilot Use TestDriver to create a test that reproduces this bug.
-Navigate to /settings, change the theme, and verify it persists after refresh.
-```
-
-The test will be created in a new branch and linked to the issue.
-
-## Mobile App Support
-
-The GitHub Mobile app supports Copilot chat, which means you can use TestDriver from your phone:
-
-1. Open the GitHub app
-2. Navigate to your repository
-3. Tap the Copilot icon
-4. Type `@testdriver` followed by your request
-
-Screenshots and test progress appear in the chat, letting you create and debug tests on the go.
-
-## Example: PR Review Workflow
-
-Here's a complete workflow for adding tests during code review:
-
-<Steps>
-  <Step title="Developer Opens PR">
-    A developer opens a pull request with a new feature.
-  </Step>
-
-  <Step title="Reviewer Requests Tests">
-    The reviewer comments:
-    ```
-    @copilot Create a TestDriver test for this user registration flow.
-    Test both successful registration and validation errors.
-    ```
-  </Step>
-
-  <Step title="Copilot Creates Tests">
-    Copilot spawns TestDriver, creates the tests, and commits them to the PR branch.
-  </Step>
-
-  <Step title="Tests Run in CI">
-    The new tests run automatically in CI, validating the feature works as expected.
-  </Step>
-</Steps>
-
-## Agent File Reference
-
-The agent file at `.github/agents/testdriver.agent.md` contains the configuration for GitHub Copilot to use TestDriver. Here's the structure:
-
-```yaml
----
-name: testdriver
-description: An expert at creating and refining automated tests using TestDriver.ai
-mcp-servers:
-  testdriver:
-    command: npx
-    args:
-      - -p
-      - testdriverai
-      - testdriverai-mcp
-    env:
-      TD_API_KEY: ${TD_API_KEY}
----
-
-# TestDriver Expert
-
-You are an expert at writing automated tests using TestDriver...
-```
-
-The `TD_API_KEY` is pulled from your repository secrets when running in GitHub Actions or from your environment when using the web interface.
-
-<Warning>
-  Make sure `TD_API_KEY` is set in your repository secrets for CI workflows. Go to **Settings → Secrets and variables → Actions** to add it.
-</Warning>