testdriverai 7.8.0-canary.6 → 7.8.0-test.1

package/agent/index.js

@@ -1941,19 +1941,18 @@ ${regression}
     // Allow explicit override via env (e.g. VITE_DOMAIN from .env)
     if (process.env.VITE_DOMAIN) return process.env.VITE_DOMAIN;
 
-    const environments = require("../lib/environments.json");
     const mapping = {
-      "https://v6.testdriver.ai": environments.stable.consoleUrl,
+      "https://api.testdriver.ai": "https://console.testdriver.ai",
+      "https://v6.testdriver.ai": "https://console.testdriver.ai",
+      "https://api-canary.testdriver.ai": "https://console-canary.testdriver.ai",
+      "https://api-test.testdriver.ai": "https://console-test.testdriver.ai",
     };
-    for (const env of Object.values(environments)) {
-      mapping[env.apiRoot] = env.consoleUrl;
-    }
     if (mapping[apiRoot]) return mapping[apiRoot];
     // Local dev: API on localhost:1337 -> Web on localhost:3001
     if (apiRoot.includes("localhost:1337") || apiRoot.includes("127.0.0.1:1337")) {
       return "http://localhost:3001";
     }
-    return environments.stable.consoleUrl;
+    return "https://console.testdriver.ai";
   }
 
   // Write session file for IDE preview (VSCode extension watches for these)

package/agent/lib/commands.js

@@ -580,12 +580,11 @@ const createCommands = (
         } else if (action === "mouseDown") {
           await sandbox.send({ type: "mousePress", button: "left", x, y, ...elementData });
         } else if (action === "mouseUp") {
-          // Move first to create drag motion, then release
-          // (pyautogui.mouseUp with x/y teleports instead of dragging)
-          await sandbox.send({ type: "moveMouse", x, y, ...elementData });
           await sandbox.send({
             type: "mouseRelease",
             button: "left",
+            x,
+            y,
             ...elementData
           });
         }

package/agent/lib/sandbox.js

@@ -1,9 +1,83 @@
+const crypto = require("crypto");
 const Ably = require("ably");
-const axios = require("axios");
 const { events } = require("../events");
 const logger = require("./logger");
 const { version } = require("../../package.json");
-const { withRetry, getSentryTraceHeaders } = require("./sdk");
+
+function getSentryTraceHeaders(sessionId) {
+  if (!sessionId) return {};
+  const traceId = crypto.createHash("md5").update(sessionId).digest("hex");
+  const spanId = crypto.randomBytes(8).toString("hex");
+  return {
+    "sentry-trace": traceId + "-" + spanId + "-1",
+    baggage:
+      "sentry-trace_id=" +
+      traceId +
+      ",sentry-sample_rate=1.0,sentry-sampled=true",
+  };
+}
+
+function httpPost(apiRoot, path, body, timeout) {
+  const http = require("http");
+  const https = require("https");
+  const url = new URL(apiRoot + path);
+  const transport = url.protocol === "https:" ? https : http;
+  const bodyStr = JSON.stringify(body);
+
+  return new Promise(function (resolve, reject) {
+    var timeoutId = timeout
+      ? setTimeout(function () {
+          req.destroy();
+          reject(
+            new Error("HTTP request timed out after " + timeout + "ms"),
+          );
+        }, timeout)
+      : null;
+
+    var req = transport.request(
+      url,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(bodyStr),
+          "Connection": "close",
+        },
+      },
+      function (res) {
+        var data = "";
+        res.on("data", function (chunk) {
+          data += chunk;
+        });
+        res.on("end", function () {
+          if (timeoutId) clearTimeout(timeoutId);
+          try {
+            var parsed = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              var err = new Error(
+                parsed.errorMessage ||
+                  parsed.message ||
+                  "HTTP " + res.statusCode,
+              );
+              err.responseData = parsed;
+              reject(err);
+            } else {
+              resolve(parsed);
+            }
+          } catch (e) {
+            reject(new Error("Failed to parse API response: " + data));
+          }
+        });
+      },
+    );
+    req.on("error", function (err) {
+      if (timeoutId) clearTimeout(timeoutId);
+      reject(err);
+    });
+    req.write(bodyStr);
+    req.end();
+  });
+}
 
 const createSandbox = function (emitter, analytics, sessionInstance) {
   class Sandbox {
@@ -31,12 +105,6 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
       this._lastConnectParams = null;
       this._teamId = null;
       this._sandboxId = null;
-
-      // Rate limiting state for Ably publishes (Ably limits to 50 msg/sec per connection)
-      this._publishLastTime = 0;
-      this._publishMinIntervalMs = 25; // 40 msg/sec max, safely under Ably's 50 limit
-      this._publishCount = 0;
-      this._publishWindowStart = Date.now();
     }
 
     getTraceId() {
@@ -230,79 +298,40 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
     }
 
     /**
-     * POST to the API with retry for transient network errors (via withRetry)
-     * and infinite polling for CONCURRENCY_LIMIT_EXCEEDED (until vitest's
-     * testTimeout kills the test).
+     * Wrapper around httpPost that retries when the server responds with
+     * CONCURRENCY_LIMIT_EXCEEDED (HTTP 429).  Instead of failing the test
+     * immediately, we wait for a slot to become available — polling every
+     * 10 s until vitest's testTimeout kills the test.
      */
     async _httpPostWithConcurrencyRetry(path, body, timeout) {
-      var concurrencyRetryInterval = 10000; // 10 seconds between concurrency retries
+      var retryInterval = 10000; // 10 seconds between retries
       var startTime = Date.now();
-      var sessionId = this.sessionInstance ? this.sessionInstance.get() : null;
-
-      var self = this;
-      var makeRequest = function () {
-        return axios({
-          method: "post",
-          url: self.apiRoot + path,
-          data: body,
-          headers: {
-            "Content-Type": "application/json",
-            "User-Agent": "TestDriverSDK/" + version + " (Node.js " + process.version + ")",
-            ...getSentryTraceHeaders(sessionId),
-          },
-          timeout: timeout || 120000,
-        });
-      };
 
       while (true) {
         try {
-          var response = await withRetry(makeRequest, {
-            retryConfig: {
-              maxRetries: 3,
-              baseDelayMs: 2000,
-              retryableStatusCodes: [500, 502, 503, 504], // Don't retry 429 — handled below
-            },
-            onRetry: function (attempt, error, delayMs) {
-              var elapsed = Date.now() - startTime;
-              logger.warn(
-                "Transient network error: " + (error.message || error.code) +
-                  " — POST " + path +
-                  " — retry " + attempt + "/3" +
-                  " in " + (delayMs / 1000).toFixed(1) + "s" +
-                  " (" + Math.round(elapsed / 1000) + "s elapsed)...",
-              );
-            },
-          });
-          return response.data;
+          return await httpPost(this.apiRoot, path, body, timeout);
         } catch (err) {
-          // Concurrency limit — poll forever until a slot opens
-          var responseData = err.response && err.response.data;
-          if (responseData && responseData.errorCode === "CONCURRENCY_LIMIT_EXCEEDED") {
-            var elapsed = Date.now() - startTime;
-            logger.log(
-              "Concurrency limit reached — waiting " +
-                concurrencyRetryInterval / 1000 +
-                "s for a slot to become available (" +
-                Math.round(elapsed / 1000) +
-                "s elapsed)...",
-            );
-            await new Promise(function (resolve) {
-              var t = setTimeout(resolve, concurrencyRetryInterval);
-              if (t.unref) t.unref();
-            });
-            continue;
-          }
+          var isConcurrencyLimit =
+            err.responseData &&
+            err.responseData.errorCode === "CONCURRENCY_LIMIT_EXCEEDED";
 
-          // Non-retryable HTTP error — preserve responseData for callers
-          if (responseData) {
-            var httpErr = new Error(
-              responseData.errorMessage || responseData.message || "HTTP " + err.response.status,
-            );
-            httpErr.responseData = responseData;
-            throw httpErr;
+          if (!isConcurrencyLimit) {
+            throw err;
           }
 
-          throw err;
+          var elapsed = Date.now() - startTime;
+
+          logger.log(
+            "Concurrency limit reached — waiting " +
+              retryInterval / 1000 +
+              "s for a slot to become available (" +
+              Math.round(elapsed / 1000) +
+              "s elapsed)...",
+          );
+          await new Promise(function (resolve) {
+            var t = setTimeout(resolve, retryInterval);
+            if (t.unref) t.unref();
+          });
         }
       }
     }
@@ -730,7 +759,8 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         p.catch(function () {});
       }
 
-      this._throttledPublish(this._cmdChannel, "command", message)
+      this._cmdChannel
+        .publish("command", message)
         .then(function () {
           emitter.emit(events.sandbox.sent, message);
         })
@@ -747,51 +777,6 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
       return p;
     }
 
-    /**
-     * Throttled publish to stay under Ably's 50 msg/sec per-connection limit.
-     * Also tracks and logs the current publish rate for debugging.
-     * @param {Object} channel - Ably channel to publish on
-     * @param {string} eventName - Event name for the publish
-     * @param {Object} message - Message payload
-     * @returns {Promise} - Resolves when publish completes
-     */
-    async _throttledPublish(channel, eventName, message) {
-      var self = this;
-      var now = Date.now();
-
-      // Rate limiting: wait if too soon since last publish
-      var elapsed = now - this._publishLastTime;
-      if (elapsed < this._publishMinIntervalMs) {
-        var waitMs = this._publishMinIntervalMs - elapsed;
-        await new Promise(function (resolve) {
-          var timer = setTimeout(resolve, waitMs);
-          if (timer.unref) timer.unref();
-        });
-      }
-      this._publishLastTime = Date.now();
-
-      // Metrics: track messages per second
-      this._publishCount++;
-      var windowElapsed = Date.now() - this._publishWindowStart;
-      if (windowElapsed >= 1000) {
-        var rate = (this._publishCount / windowElapsed) * 1000;
-        var rateStr = rate.toFixed(1);
-
-        // Log rate - warning if approaching limit, debug otherwise
-        if (rate > 45) {
-          logger.warn("Ably publish rate: " + rateStr + " msg/sec (approaching 50/sec limit)");
-        } else if (process.env.VERBOSE || process.env.TD_DEBUG) {
-          logger.log("Ably publish rate: " + rateStr + " msg/sec");
-        }
-
-        // Reset window
-        this._publishCount = 0;
-        this._publishWindowStart = Date.now();
-      }
-
-      return channel.publish(eventName, message);
-    }
-
     async auth(apiKey) {
       this.apiKey = apiKey;
       var sessionId = this.sessionInstance

package/agent/lib/sdk.js

@@ -231,7 +231,6 @@ const createSDK = (emitter, config, sessionInstance) => {
       let res = await withRetry(
         () => axios(url, c),
         {
-          retryConfig: { maxRetries: 2 },
           onRetry: (attempt, error, delayMs) => {
             emitter.emit(events.sdk.retry, {
               path: 'auth/exchange-api-key',
@@ -382,7 +381,6 @@ const createSDK = (emitter, config, sessionInstance) => {
             "Content-Type": "application/json",
             "User-Agent": `TestDriverSDK/${version} (Node.js ${process.version})`,
             ...(token && { Authorization: `Bearer ${token}` }),
-            ...getSentryTraceHeaders(sessionInstance.get()),
           },
           timeout: 15000,
           data: {
@@ -629,5 +627,5 @@ const createSDK = (emitter, config, sessionInstance) => {
   return { req, auth };
 };
 
-// Export the factory function and shared utilities
-module.exports = { createSDK, withRetry, getSentryTraceHeaders, sleep };
+// Export the factory function
+module.exports = { createSDK };

package/agent/lib/system.js

@@ -4,8 +4,6 @@ const os = require("os");
 const path = require("path");
 const { randomUUID } = require("crypto");
 const Jimp = require("jimp");
-const axios = require("axios");
-const { withRetry } = require("./sdk");
 const { events } = require("../events.js");
 
 const createSystem = (emitter, sandbox, config) => {
@@ -13,37 +11,79 @@ const createSystem = (emitter, sandbox, config) => {
   // Download a screenshot from S3 when the runner returns an s3Key
   // (screenshots exceed Ably's 64KB message limit)
   const downloadFromS3 = async (s3Key) => {
+    const https = require("https");
+    const http = require("http");
     const apiRoot = config["TD_API_ROOT"] || sandbox.apiRoot;
     const apiKey = sandbox.apiKey;
 
-    // Step 1: Get presigned download URL from API (with retry)
-    const response = await withRetry(
-      () => axios({
-        method: "post",
-        url: apiRoot + "/api/v7/runner/download-url",
-        data: { apiKey, s3Key },
-        headers: { "Content-Type": "application/json" },
-        timeout: 15000,
-      }),
-      {
-        retryConfig: { maxRetries: 3, baseDelayMs: 1000 },
-      },
-    );
-
-    const downloadUrl = response.data.downloadUrl;
-    if (!downloadUrl) {
-      throw new Error("No downloadUrl in response: " + JSON.stringify(response.data));
+    // Step 1: Get presigned download URL from API (with retry on rate-limit)
+    const body = JSON.stringify({ apiKey, s3Key });
+    const url = new URL(apiRoot + "/api/v7/runner/download-url");
+    const transport = url.protocol === "https:" ? https : http;
+
+    const MAX_RETRIES = 3;
+    let downloadUrl;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        downloadUrl = await new Promise((resolve, reject) => {
+          const req = transport.request(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Content-Length": Buffer.byteLength(body),
+              "Connection": "close",
+            },
+          }, (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => {
+              if (res.statusCode === 429) {
+                return reject({ retryable: true, message: "Rate limited (429) from download-url endpoint" });
+              }
+              if (res.statusCode >= 400) {
+                return reject(new Error(`download-url request failed (HTTP ${res.statusCode}): ${data}`));
+              }
+              try {
+                const parsed = JSON.parse(data);
+                if (parsed.downloadUrl) {
+                  resolve(parsed.downloadUrl);
+                } else {
+                  reject(new Error("No downloadUrl in response: " + data));
+                }
+              } catch (e) {
+                reject({ retryable: true, message: "Failed to parse download-url response: " + data });
+              }
+            });
+          });
+          req.on("error", reject);
+          req.write(body);
+          req.end();
+        });
+        break; // success — exit retry loop
+      } catch (err) {
+        if (err && err.retryable && attempt < MAX_RETRIES) {
+          const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
+          await new Promise((r) => setTimeout(r, delay));
+          continue;
+        }
+        throw err instanceof Error ? err : new Error(err.message || String(err));
+      }
     }
 
     // Step 2: Download the image from S3
-    const imageResponse = await axios({
-      method: "get",
-      url: downloadUrl,
-      responseType: "arraybuffer",
-      timeout: 30000,
+    const imageUrl = new URL(downloadUrl);
+    const s3Transport = imageUrl.protocol === "https:" ? https : http;
+
+    const imageBuffer = await new Promise((resolve, reject) => {
+      s3Transport.get(downloadUrl, { headers: { "Connection": "close" } }, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      }).on("error", reject);
     });
 
-    return Buffer.from(imageResponse.data).toString("base64");
+    return imageBuffer.toString("base64");
   };
 
   const screenshot = async (options) => {

package/ai/skills/testdriver-running-tests/SKILL.md

@@ -133,7 +133,7 @@ export default defineConfig({
 <Card
   title="View Plans & Pricing"
   icon="credit-card"
-  href="/v7/hosted"
+  href="/v7/cloud"
 >
   Compare plans and find the right level of parallelization for your team.
 </Card>

package/docs/changelog.mdx

@@ -5,8 +5,8 @@ rss: true
 icon: "code-compare"
 ---
 
-<Update label="v7.8.0-test.6" description="March 2026" tags={["test"]}>
-🔧 Maintenance
+<Update label="v7.8.0-canary.5" description="March 2026" tags={["canary"]}>
+This release includes all changes from v7.8.0-canary.4 with version bumps.
 
 ✨ New features
 

package/docs/docs.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://mintlify.com/docs.json",
-  "theme": "almond",
+  "theme": "palm",
   "name": "TestDriver",
   "colors": {
     "primary": "#b3d334",
@@ -48,20 +48,20 @@
                   "/v7/examples/windows-installer"
                 ]
               },
-
               {
-                "group": "Deployment",
+                "group": "Plans & Pricing",
                 "icon": "server",
                 "pages": [
-                  "/v7/hosted",
-                  "/v7/self-hosted"
+                  "/v7/cloud",
+                  "/v7/self-hosted",
+                  "/v7/enterprise"
                 ]
               },
               "/changelog"
             ]
           },
           {
-            "group": "Guide",
+            "group": "Creating Tests",
             "pages": [
               "/v7/generating-tests",
               "/v7/device-config",
@@ -95,33 +95,32 @@
             ]
           },
           {
-            "group": "SDK Reference",
+            "group": "Actions",
+            "pages": [
+              "/v7/ai",
+              "/v7/assert",
+              "/v7/captcha",
+              "/v7/click",
+              "/v7/double-click",
+              "/v7/exec",
+              "/v7/find",
+              "/v7/focus-application",
+              "/v7/hover",
+              "/v7/mouse-down",
+              "/v7/mouse-up",
+              "/v7/parse",
+              "/v7/press-keys",
+              "/v7/right-click",
+              "/v7/screenshot",
+              "/v7/type",
+              "/v7/scroll"
+            ]
+          },
+          {
+            "group": "SDK",
             "pages": [
-              "/v7/client",
               "/v7/elements",
-              {
-                "group": "Actions",
-                "icon": "bolt",
-                "pages": [
-                  "/v7/ai",
-                  "/v7/assert",
-                  "/v7/captcha",
-                  "/v7/click",
-                  "/v7/double-click",
-                  "/v7/exec",
-                  "/v7/find",
-                  "/v7/focus-application",
-                  "/v7/hover",
-                  "/v7/mouse-down",
-                  "/v7/mouse-up",
-                  "/v7/parse",
-                  "/v7/press-keys",
-                  "/v7/right-click",
-                  "/v7/screenshot",
-                  "/v7/scroll",
-                  "/v7/type"
-                ]
-              },
+              "/v7/client",
               "/v7/dashcam"
             ]
           }  ]

package/docs/v7/{hosted.mdx → cloud.mdx}

@@ -1,56 +1,18 @@
 ---
-title: "Hosted"
-sidebarTitle: "Hosted"
+title: "Cloud Plan"
+sidebarTitle: "Cloud"
 description: "The fastest way to get started with TestDriver. Just set your API key and start testing."
 icon: "cloud"
-mode: "wide"
 ---
 
-Hosted pricing is based on **device-seconds**: the amount of time your tests run on **our infrastructure**.
+Cloud 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. 
+Cloud is the default when you follow the Quickstart guide. 
 <Card
   title="Try the Quickstart"  
   icon="play"
@@ -140,7 +102,7 @@ To prevent tests from failing due to exceeding your license slot limit, we recom
 
 ## 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:
+Cloud 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