@testdriverai/agent 7.8.0-test.74 → 7.9.0-canary.1

package/agent/lib/sandbox.js

@@ -536,6 +536,162 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         }
       }
 
+      // ─── Handle pending slot claim (trigger.dev waitpoint flow) ────
+      // The API returned early with status: 'pending'. The SDK has now
+      // connected to Ably and entered presence (done in _initAbly above).
+      // Wait for the claim-slot task to publish slot-approved or slot-denied
+      // on the control channel, then re-call authenticate with slotApproved.
+      // On slot-denied, we poll forever (re-calling authenticate every 10s)
+      // until a slot opens, matching _httpPostWithConcurrencyRetry behavior.
+      var concurrencyRetryInterval = 10000;
+      var slotPollStart = Date.now();
+      while (reply.status === 'pending') {
+        logger.log('Slot claim pending — waiting for approval via Ably...');
+
+        var self = this;
+        var slotResolved = false;
+        var slotResolve, slotReject;
+        var slotDecisionPromise = new Promise(function (resolve, reject) {
+          slotResolve = resolve;
+          slotReject = reject;
+        });
+
+        var slotTimeout = setTimeout(function () {
+          if (slotResolved) return;
+          slotResolved = true;
+          try { self._sessionChannel.unsubscribe('control', onSlotControl); } catch (_) {}
+          slotReject(new Error('Slot claim timed out waiting for approval'));
+        }, 60000); // 60s timeout
+        if (slotTimeout.unref) slotTimeout.unref();
+
+        function onSlotControl(msg) {
+          var data = msg.data;
+          if (!data) return;
+          if (data.type === 'slot-approved') {
+            if (slotResolved) return;
+            slotResolved = true;
+            clearTimeout(slotTimeout);
+            try { self._sessionChannel.unsubscribe('control', onSlotControl); } catch (_) {}
+            slotResolve({ approved: true, data: data });
+          } else if (data.type === 'slot-denied') {
+            if (slotResolved) return;
+            slotResolved = true;
+            clearTimeout(slotTimeout);
+            try { self._sessionChannel.unsubscribe('control', onSlotControl); } catch (_) {}
+            slotResolve({ approved: false, data: data });
+          }
+        }
+
+        // Subscribe FIRST, then check history to close the race window
+        // between presence enter (done in _initAbly) and this subscription.
+        // The claim-slot task fires in response to presence enter, so the
+        // decision may already be published by the time we get here.
+        var slotControlSub = await self._sessionChannel.subscribe('control', onSlotControl);
+
+        // Check for decisions published before this subscription was active
+        if (!slotResolved && slotControlSub) {
+          try {
+            var histPage = await slotControlSub.historyBeforeSubscribe({ limit: 10 });
+            while (histPage && !slotResolved) {
+              for (var hi = 0; hi < histPage.items.length; hi++) {
+                onSlotControl(histPage.items[hi]);
+                if (slotResolved) break;
+              }
+              histPage = (!slotResolved && histPage.hasNext()) ? await histPage.next() : null;
+            }
+          } catch (histErr) {
+            logger.warn('[slots] Failed to check history for slot decision: ' + (histErr.message || histErr));
+          }
+        }
+
+        var slotDecision = await slotDecisionPromise;
+
+        if (!slotDecision.approved) {
+          // Slot denied — disconnect Ably and re-try the full authenticate
+          // flow after a delay, polling forever until a slot opens.
+          var elapsed = Date.now() - slotPollStart;
+          logger.log(
+            'Slot denied: ' + (slotDecision.data.message || 'concurrency limit reached') +
+            ' — waiting ' + (concurrencyRetryInterval / 1000) + 's before retrying' +
+            ' (' + Math.round(elapsed / 1000) + 's elapsed)...'
+          );
+          logger.log('Upgrade for more slots → https://console.testdriver.ai/checkout/team');
+          try {
+            if (this._ably) this._ably.close();
+            this._ably = null;
+            this._sessionChannel = null;
+          } catch (_) {}
+
+          await new Promise(function (resolve) {
+            var t = setTimeout(resolve, concurrencyRetryInterval);
+            if (t.unref) t.unref();
+          });
+
+          // Re-call authenticate — this goes through _httpPostWithConcurrencyRetry
+          // so transient HTTP errors are also handled. The new reply will either
+          // be 'pending' again (loop continues) or succeed directly.
+          reply = await this._httpPostWithConcurrencyRetry(
+            "/api/v7/sandbox/authenticate",
+            body,
+            timeout,
+          );
+
+          if (!reply.success && reply.status !== 'pending') {
+            var retryErr = new Error(
+              reply.errorMessage || "Failed to allocate sandbox",
+            );
+            retryErr.responseData = reply;
+            throw retryErr;
+          }
+
+          // Re-init Ably if we got a new pending reply with fresh credentials
+          if (reply.status === 'pending' && reply.ably && reply.ably.token) {
+            this._sandboxId = reply.sandboxId;
+            this._teamId = reply.teamId;
+            await this._initAbly(reply.ably.token, reply.ably.channel);
+            this.instanceSocketConnected = true;
+          }
+
+          continue; // loop back to wait for the next slot decision
+        }
+
+        logger.log('Slot approved — provisioning sandbox...');
+
+        // Re-call authenticate with slotApproved flag to trigger provisioning
+        // Keep the same sandboxId so the Ably channel stays valid
+        var provisionBody = {
+          apiKey: this.apiKey,
+          version: version,
+          os: message.os || this.os || 'linux',
+          session: sessionId,
+          apiRoot: this.apiRoot,
+          sandboxId: this._sandboxId,
+          slotApproved: true,
+        };
+        if (message.resolution) provisionBody.resolution = message.resolution;
+        if (message.ci) provisionBody.ci = message.ci;
+        if (message.ami) provisionBody.ami = message.ami;
+        if (message.instanceType) provisionBody.instanceType = message.instanceType;
+        if (message.e2bTemplateId) provisionBody.e2bTemplateId = message.e2bTemplateId;
+        if (message.keepAlive !== undefined) provisionBody.keepAlive = message.keepAlive;
+
+        reply = await this._httpPostWithConcurrencyRetry(
+          "/api/v7/sandbox/authenticate",
+          provisionBody,
+          timeout,
+        );
+
+        if (!reply.success) {
+          var provisionErr = new Error(
+            reply.errorMessage || "Failed to provision sandbox after approval",
+          );
+          provisionErr.responseData = reply;
+          throw provisionErr;
+        }
+
+        break; // slot approved and provisioned — exit the while loop
+      }
+
       if (message.type === "create") {
         // E2B (Linux) sandboxes return a url directly.
         // We still need to wait for runner.ready since sandbox-agent.js runs inside E2B.

package/agent/lib/sdk.js

@@ -273,9 +273,9 @@ const createSDK = (emitter, config, sessionInstance) => {
     if (status >= 500) {
       const serverError = new Error(
         data?.message ||
-        `TestDriver API is currently unavailable (HTTP ${status}). Please try again later.`
+        `An error occurred on the TestDriver server (HTTP ${status}). Please try again later.`
       );
-      serverError.code = data?.error || "API_UNAVAILABLE";
+      serverError.code = data?.error || "SERVER_ERROR";
       serverError.isServerError = true;
       serverError.originalError = error;
       return serverError;
@@ -567,9 +567,9 @@ const createSDK = (emitter, config, sessionInstance) => {
       if (status >= 500) {
         const serverError = new Error(
           error.response?.data?.message ||
-          `TestDriver API is currently unavailable (HTTP ${status}). Please try again later.`
+          `An error occurred on the TestDriver server (HTTP ${status}). Please try again later.`
         );
-        serverError.code = error.response?.data?.error || "API_UNAVAILABLE";
+        serverError.code = error.response?.data?.error || "SERVER_ERROR";
         serverError.isServerError = true;
         serverError.originalError = error;
         serverError.path = path;

package/ai/skills/testdriver-enterprise/SKILL.md

@@ -1,114 +1,7 @@
 ---
 name: testdriver:enterprise
-description: Air-gapped security and full customization for demanding environments
+description: Self-hosted enterprise deployments with assisted setup and dedicated support
 ---
 <!-- Generated from enterprise.mdx. DO NOT EDIT. -->
 
-## Why Enterprise?
-
-<CardGroup cols={2}>
-  <Card title="Air-Gapped Security" icon="shield-check">
-    Deploy everything in your environment. No data leaves your network. Complete isolation from external services.
-  </Card>
-  <Card title="Full Customization" icon="gear">
-    Custom integrations, dedicated infrastructure, and tailored solutions for your unique requirements.
-  </Card>
-  <Card title="Self-Hosted Dashboard & API" icon="server">
-    Run the entire TestDriver stack — dashboard, API, and test infrastructure — within your own environment.
-  </Card>
-  <Card title="Dedicated Support" icon="headset">
-    Direct access to our engineering team for implementation, customization, and ongoing support.
-  </Card>
-</CardGroup>
-
-## Who Needs Enterprise?
-
-Enterprise is designed for organizations that:
-
-- **Require air-gapped deployments** — Regulated industries, government, defense, or strict compliance requirements
-- **Cannot use external APIs** — Data must never leave your network perimeter
-- **Need custom integrations** — Unique CI/CD systems, internal tools, or specialized workflows
-- **Want dedicated support** — Direct engineering support for complex implementations
-
-## What's Included
-
-### Fully Self-Hosted Stack
-
-Unlike [Self-Hosted](/v7/self-hosted) (which uses TestDriver's hosted dashboard and API), Enterprise deploys everything in your environment:
-
-| Component | Self-Hosted | Enterprise |
-|-----------|-------------|------------|
-| Test Sandboxes | Your infrastructure | Your infrastructure |
-| Dashboard | TestDriver hosted | Your infrastructure |
-| API | TestDriver hosted | Your infrastructure |
-| AI Processing | Your API keys | Your infrastructure |
-| Data Storage | Your AWS account | Your infrastructure |
-
-### Custom Contract Terms
-
-- Volume-based pricing
-- Custom SLAs
-- Dedicated support channels
-- Professional services for implementation
-- Training for your team
-
-## Implementation Process
-
-<Steps>
-  <Step title="Discovery Call">
-    Discuss your requirements, security constraints, and integration needs with our team.
-  </Step>
-  
-  <Step title="Architecture Review">
-    Our engineers design a deployment architecture that meets your security and compliance requirements.
-  </Step>
-  
-  <Step title="Deployment">
-    We work with your team to deploy TestDriver within your environment, including dashboard, API, and test infrastructure.
-  </Step>
-  
-  <Step title="Integration">
-    Connect TestDriver to your CI/CD pipelines, internal tools, and workflows.
-  </Step>
-  
-  <Step title="Training & Handoff">
-    Comprehensive training for your team on operating and maintaining the deployment.
-  </Step>
-</Steps>
-
-## Security & Compliance
-
-Enterprise deployments support:
-
-- **SOC 2** compliance requirements
-- **HIPAA** for healthcare applications
-- **FedRAMP** for government deployments
-- **PCI DSS** for payment processing
-- **Custom compliance frameworks** as needed
-
-<Note>
-  All data remains within your network perimeter. TestDriver has no access to your test results, application data, or infrastructure.
-</Note>
-
-## Comparison: Self-Hosted vs Enterprise
-
-| Feature | Self-Hosted | Enterprise |
-|---------|-------------|------------|
-| **Test Infrastructure** | Your AWS | Your infrastructure (any) |
-| **Dashboard** | TestDriver cloud | Your infrastructure |
-| **API** | TestDriver cloud | Your infrastructure |
-| **Data Location** | Your AWS + TestDriver | 100% your infrastructure |
-| **Network Requirements** | Internet access | Can be fully air-gapped |
-| **Cloud Providers** | AWS only | Any (AWS, Azure, GCP, on-prem) |
-| **Support** | Standard | Dedicated engineering |
-| **Contract** | Standard licensing | Custom terms |
-
-## Get Started
-
-<Card
-  title="Schedule a Consultation"
-  icon="calendar"
-  href="https://calendly.com/d/cq23-qyn-3v6/testdriver-ai-demo"
->
-  Discuss your requirements with our team and get a custom proposal for your Enterprise deployment.
-</Card>
+This page has moved to [Self-Hosted](/v7/self-hosted).

package/ai/skills/testdriver-hosted/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: testdriver:hosted
+description: The fastest way to get started with TestDriver. Just set your API key and start testing.
+---
+<!-- Generated from hosted.mdx. DO NOT EDIT. -->
+
+Hosted pricing is based on **device-seconds**: the amount of time your tests run on **our infrastructure**.
+
+- **Zero Setup** — Start testing immediately. No DevOps required.
+- **Free Tier** — Get started with a limited preview at no cost.
+- **Pay As You Go** — Only pay for the device-seconds you use.
+
+## Hosted Plans
+
+<CardGroup cols={3}>
+  <Card title="Free Trial" icon="gift" href="https://docs.testdriver.ai">
+    **$0/month**
+    
+    - 1 Concurrent Sandbox
+    - 60 Minutes Included
+    - 1 Team User
+    - Community Support
+  </Card>
+  
+  <Card title="Pro" icon="rocket" href="https://console.testdriver.ai/checkout/pro">
+    **$20/month**
+    
+    - 2 Concurrent Sandboxes
+    - 600 Minutes Included
+    - Overage: $0.002/second
+    - 1 Team User
+    - Test Recordings
+    - Community Support
+  </Card>
+  
+  <Card title="Team" icon="users" href="https://console.testdriver.ai/checkout/team">
+    **$600/month**
+    
+    - 8 Concurrent Sandboxes
+    - 10,000 Minutes Included
+    - Overage: $0.001/second
+    - 5 Team Users
+    - Test Recordings
+    - Private Support
+    - Test Analytics
+    - CPU, RAM, & Network Profiles
+  </Card>
+</CardGroup>
+
+## Get Started
+Hosted is the default when you follow the Quickstart guide. 
+<Card
+  title="Try the Quickstart"  
+  icon="play"
+  href="/v7/quickstart"
+>
+  Set your API key and start testing in minutes.
+</Card>
+
+## Parallel Testing Limits
+
+Your account has a set number of **license slots** that determine how many devices can run simultaneously. You can view your available slots in the [TestDriver Dashboard](https://console.testdriver.ai).
+
+<Info>
+  **When is a slot in use?** A license slot is occupied when a test client is connected. As soon as your device is destroyed the slot becomes available immediately.
+</Info>
+
+## Avoiding Slot Conflicts
+
+To prevent tests from failing due to exceeding your license slot limit, we recommend two key configurations:
+
+<AccordionGroup>
+  <Accordion title="Set Maximum Concurrency in Vitest">
+    Limit concurrent tests to match your available license slots:
+
+    ```javascript vitest.config.mjs
+    import { defineConfig } from 'vitest/config';
+    import { TestDriver } from 'testdriverai/vitest';
+
+    export default defineConfig({
+      test: {
+        testTimeout: 900000,
+        hookTimeout: 900000,
+        maxConcurrency: 5, // Set to your license slot limit
+        reporters: ['default', TestDriver()],
+        setupFiles: ['testdriverai/vitest/setup'],
+      },
+    });
+    ```
+
+    <Tip>
+      Check your slot count at [console.testdriver.ai](https://console.testdriver.ai) and set `maxConcurrency` to that number or lower.
+    </Tip>
+  </Accordion>
+
+  <Accordion title="Use GitHub Concurrency Keys">
+    Prevent multiple workflow runs from competing for the same slots by using [GitHub's concurrency controls](https://docs.github.com/actions/writing-workflows/choosing-what-your-workflow-does/control-the-concurrency-of-workflows-and-jobs):
+
+    ```yaml .github/workflows/test.yml
+    name: Tests
+
+    on:
+      push:
+        branches: [main]
+      pull_request:
+
+    # Prevent concurrent runs from competing for license slots
+    concurrency:
+      group: ${{ github.workflow }}-${{ github.ref }}
+      cancel-in-progress: true
+
+    jobs:
+      test:
+        runs-on: ubuntu-latest
+        steps:
+          - uses: actions/checkout@v4
+          
+          - name: Setup Node.js
+            uses: actions/setup-node@v4
+            with:
+              node-version: '20'
+          
+          - name: Install dependencies
+            run: npm install
+          
+          - name: Run tests
+            run: vitest run
+            env:
+              TD_API_KEY: ${{ secrets.TD_API_KEY }}
+    ```
+
+    The `concurrency` block ensures:
+    - Only one workflow run per branch runs at a time
+    - New pushes cancel in-progress runs on the same branch
+    - Different branches/PRs can run in parallel (up to your slot limit)
+  </Accordion>
+</AccordionGroup>
+
+## When to Consider Self-Hosted
+
+Hosted is perfect for getting started and for teams that want zero infrastructure management. However, you might consider [Self-Hosted](/v7/self-hosted) if you:
+
+- Want to escape per-second billing with a flat license fee
+- Require greater concurrency than offered in Cloud plans
+- Need full control over your infrastructure and privacy
+- Want to use your own AI API keys
+- Require custom hardware configurations
+- Have high test volumes that make self-hosting more economical
+
+<Card
+  title="Explore Self-Hosted"
+  icon="server"
+  href="/v7/self-hosted"
+>
+  Learn about self-hosting for unlimited test execution at a flat rate.
+</Card>

package/ai/skills/testdriver-mcp/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: testdriver:mcp
-description: mcp
+description: Execute natural language tasks using AI
 ---
 <!-- Generated from mcp.mdx. DO NOT EDIT. -->
 
-
+## Overview

package/ai/skills/testdriver-quickstart/SKILL.md

@@ -9,7 +9,7 @@ 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="Automatic Setup">
+  <Tab title="CLI" icon="terminal">
 
     Get started quickly with the TestDriver CLI.
 
@@ -39,7 +39,35 @@ TestDriver makes it easy to write automated computer-use tests for web browsers,
       </Step>
     </Steps>
   </Tab>
-  <Tab title="Manual Setup">
+  <Tab title="GitHub Copilot" icon="github">
+
+    Use the TestDriver VS Code extension with GitHub Copilot for an AI-powered testing workflow.
+
+    <Card
+      title="Install TestDriver for VS Code"
+      icon="/images/content/extension/vscode.svg"
+      href="vscode:extension/testdriver.testdriver"
+      arrow
+      horizontal
+    >
+    </Card>
+
+    The extension provides one-click sign-in, project initialization, a live preview panel for watching tests execute, and MCP server configuration for GitHub Copilot.
+
+    Once installed, follow the full setup guide to configure MCP and start building tests with AI assistance:
+
+    <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>
+
+  </Tab>
+  <Tab title="Manual" icon="wrench">
 
     Install TestDriver and manually create the files yourself.