testdriverai 7.8.0-test.7 → 7.8.0-test.9

package/agent/index.js

@@ -1941,18 +1941,19 @@ ${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://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",
+      "https://v6.testdriver.ai": environments.stable.consoleUrl,
     };
+    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 "https://console.testdriver.ai";
+    return environments.stable.consoleUrl;
   }
 
   // Write session file for IDE preview (VSCode extension watches for these)

package/agent/lib/commands.js

@@ -580,11 +580,12 @@ 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/http.js

@@ -0,0 +1,144 @@
+/**
+ * Shared HTTP client for the TestDriver SDK.
+ *
+ * All SDK HTTP traffic should go through these helpers so that
+ * User-Agent, timeouts, Sentry tracing headers, and response
+ * parsing are handled in one place.
+ *
+ * Uses axios under the hood — the same library the rest of the SDK
+ * already depends on.
+ */
+
+const axios = require("axios");
+const crypto = require("crypto");
+const { version } = require("../../package.json");
+
+const USER_AGENT = `TestDriverSDK/${version} (Node.js ${process.version})`;
+
+/**
+ * Generate Sentry distributed-tracing headers from a session ID.
+ * Both sandbox.js and sdk.js duplicated this — it now lives here.
+ *
+ * @param {string} sessionId
+ * @returns {object} Headers object (empty if no sessionId)
+ */
+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",
+  };
+}
+
+/**
+ * Build common request headers.
+ * @param {object} [extra] - Additional headers to merge
+ * @returns {object}
+ */
+function baseHeaders(extra) {
+  return {
+    "User-Agent": USER_AGENT,
+    ...extra,
+  };
+}
+
+/**
+ * POST JSON to `url` and return the parsed response body.
+ *
+ * @param {string} url    - Absolute URL
+ * @param {object} [data] - JSON body
+ * @param {object} [opts] - Extra axios config (headers, timeout, …)
+ * @returns {Promise<object>} Parsed response data
+ */
+async function httpPost(url, data, opts = {}) {
+  const { headers: extraHeaders, ...rest } = opts;
+  const res = await axios({
+    method: "post",
+    url,
+    headers: baseHeaders({
+      "Content-Type": "application/json",
+      ...extraHeaders,
+    }),
+    data,
+    timeout: opts.timeout || 30000,
+    ...rest,
+  });
+  return res.data;
+}
+
+/**
+ * GET `url` and return the parsed response body.
+ *
+ * @param {string} url    - Absolute URL
+ * @param {object} [opts] - Extra axios config
+ * @returns {Promise<object>} Parsed response data
+ */
+async function httpGet(url, opts = {}) {
+  const { headers: extraHeaders, ...rest } = opts;
+  const res = await axios({
+    method: "get",
+    url,
+    headers: baseHeaders(extraHeaders),
+    timeout: opts.timeout || 30000,
+    ...rest,
+  });
+  return res.data;
+}
+
+/**
+ * PUT data to `url` (e.g. S3 presigned upload).
+ *
+ * @param {string} url    - Absolute URL
+ * @param {Buffer|string} data - Request body
+ * @param {object} [opts] - Extra axios config (headers, timeout, …)
+ * @returns {Promise<object>} Parsed response data (or empty object for 2xx with no body)
+ */
+async function httpPut(url, data, opts = {}) {
+  const { headers: extraHeaders, ...rest } = opts;
+  const res = await axios({
+    method: "put",
+    url,
+    headers: baseHeaders(extraHeaders),
+    data,
+    timeout: opts.timeout || 30000,
+    maxBodyLength: Infinity,
+    maxContentLength: Infinity,
+    ...rest,
+  });
+  return res.data;
+}
+
+/**
+ * Download a URL as a Buffer (e.g. screenshot from S3).
+ *
+ * @param {string} url    - Absolute URL
+ * @param {object} [opts] - Extra axios config
+ * @returns {Promise<Buffer>}
+ */
+async function downloadBuffer(url, opts = {}) {
+  const { headers: extraHeaders, ...rest } = opts;
+  const res = await axios({
+    method: "get",
+    url,
+    headers: baseHeaders(extraHeaders),
+    responseType: "arraybuffer",
+    timeout: opts.timeout || 60000,
+    ...rest,
+  });
+  return Buffer.from(res.data);
+}
+
+module.exports = {
+  httpPost,
+  httpGet,
+  httpPut,
+  downloadBuffer,
+  getSentryTraceHeaders,
+  USER_AGENT,
+  baseHeaders,
+};

package/agent/lib/sandbox.js

@@ -1,83 +1,9 @@
-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");
-
-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 { withRetry, getSentryTraceHeaders } = require("./sdk");
 
 const createSandbox = function (emitter, analytics, sessionInstance) {
   class Sandbox {
@@ -105,6 +31,12 @@ 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() {
@@ -298,40 +230,79 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
     }
 
     /**
-     * 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.
+     * 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).
      */
     async _httpPostWithConcurrencyRetry(path, body, timeout) {
-      var retryInterval = 10000; // 10 seconds between retries
+      var concurrencyRetryInterval = 10000; // 10 seconds between concurrency 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 {
-          return await httpPost(this.apiRoot, path, body, timeout);
+          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;
         } catch (err) {
-          var isConcurrencyLimit =
-            err.responseData &&
-            err.responseData.errorCode === "CONCURRENCY_LIMIT_EXCEEDED";
-
-          if (!isConcurrencyLimit) {
-            throw 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 elapsed = Date.now() - startTime;
+          // 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;
+          }
 
-          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();
-          });
+          throw err;
         }
       }
     }
@@ -759,8 +730,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         p.catch(function () {});
       }
 
-      this._cmdChannel
-        .publish("command", message)
+      this._throttledPublish(this._cmdChannel, "command", message)
         .then(function () {
           emitter.emit(events.sandbox.sent, message);
         })
@@ -777,6 +747,51 @@ 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,6 +231,7 @@ 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',
@@ -381,6 +382,7 @@ 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: {
@@ -627,5 +629,5 @@ const createSDK = (emitter, config, sessionInstance) => {
   return { req, auth };
 };
 
-// Export the factory function
-module.exports = { createSDK };
+// Export the factory function and shared utilities
+module.exports = { createSDK, withRetry, getSentryTraceHeaders, sleep };

package/agent/lib/system.js

@@ -4,6 +4,8 @@ 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) => {
@@ -11,79 +13,37 @@ 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 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 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 2: Download the image from S3
-    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);
+    const imageResponse = await axios({
+      method: "get",
+      url: downloadUrl,
+      responseType: "arraybuffer",
+      timeout: 30000,
     });
 
-    return imageBuffer.toString("base64");
+    return Buffer.from(imageResponse.data).toString("base64");
   };
 
   const screenshot = async (options) => {