testdriverai 7.3.28 → 7.3.29

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [7.3.29](https://github.com/testdriverai/testdriverai/compare/v7.3.28...v7.3.29) (2026-02-20)
+
+
+
 ## [7.3.28](https://github.com/testdriverai/testdriverai/compare/v7.3.27...v7.3.28) (2026-02-20)
 
 

package/interfaces/vitest-plugin.mjs

@@ -1299,18 +1299,30 @@ function calculateStatsFromModules(testModules) {
   let failedTests = 0;
   let skippedTests = 0;
 
+  // Guard against corrupt or circular test tree structures
+  // (can happen with --sequence.concurrent in some Vitest versions)
+  const seen = new Set();
+
   for (const testModule of testModules) {
-    for (const testCase of testModule.children.allTests()) {
-      const result = testCase.result();
-      if (result.state === "passed") {
-        passedTests++;
-        totalTests++;
-      } else if (result.state === "failed") {
-        failedTests++;
-        totalTests++;
-      } else if (result.state === "skipped") {
-        skippedTests++;
+    try {
+      for (const testCase of testModule.children.allTests()) {
+        // Deduplicate - skip if we've already counted this test
+        if (seen.has(testCase.id)) continue;
+        seen.add(testCase.id);
+
+        const result = testCase.result();
+        if (result.state === "passed") {
+          passedTests++;
+          totalTests++;
+        } else if (result.state === "failed") {
+          failedTests++;
+          totalTests++;
+        } else if (result.state === "skipped") {
+          skippedTests++;
+        }
       }
+    } catch (err) {
+      logger.warn(`Error calculating stats for module: ${err.message}`);
     }
   }
 

package/lib/vitest/hooks.mjs

@@ -59,113 +59,132 @@ function checkVitestVersion() {
 checkVitestVersion();
 
 /**
- * Set up console spies using Vitest's vi.spyOn to intercept console logs
- * and forward them to the sandbox for Dashcam visibility.
- * This is test-isolated and doesn't cause conflicts with concurrent tests.
- * @param {TestDriver} client - TestDriver client instance
- * @param {string} taskId - Unique task identifier for this test
+ * Singleton console spy that forwards logs to all active sandbox connections.
+ *
+ * When --sequence.concurrent is used, multiple tests run at the same time in
+ * the same worker process.  The previous implementation called vi.spyOn on
+ * console.log once per test, stacking N mock layers deep.  Every console.log
+ * then cascaded through all N layers — each one calling JSON.stringify inside
+ * forwardToSandbox — easily exceeding the call-stack limit for ≥ ~30 tests.
+ *
+ * This singleton intercepts the console methods exactly **once** and keeps a
+ * Set of active sandbox clients.  Each log call is forwarded to every active
+ * client's sandbox in O(N) *flat* iterations instead of O(N) nested frames.
  */
-function setupConsoleSpy(client, taskId) {
-  // Debug logging for console spy setup
-  const debugConsoleSpy = process.env.TD_DEBUG_CONSOLE_SPY === "true";
-  if (debugConsoleSpy) {
-    process.stdout.write(`[DEBUG setupConsoleSpy] taskId: ${taskId}\n`);
-    process.stdout.write(
-      `[DEBUG setupConsoleSpy] client.sandbox exists: ${!!client.sandbox}\n`,
-    );
-    process.stdout.write(
-      `[DEBUG setupConsoleSpy] client.sandbox?.instanceSocketConnected: ${client.sandbox?.instanceSocketConnected}\n`,
-    );
-    process.stdout.write(
-      `[DEBUG setupConsoleSpy] client.sandbox?.send: ${typeof client.sandbox?.send}\n`,
-    );
-  }
+const _consoleSpy = {
+  /** @type {Set<import('../../sdk.js').default>} */
+  activeClients: new Set(),
+  installed: false,
+  /** Original (un-spied) console references, captured once. */
+  originals: /** @type {{ log: Function, error: Function, warn: Function, info: Function } | null} */ (null),
+  spies: /** @type {{ log: any, error: any, warn: any, info: any } | null} */ (null),
+};
 
-  // Track forwarding stats
-  let forwardedCount = 0;
-  let skippedCount = 0;
+const debugConsoleSpy = process.env.TD_DEBUG_CONSOLE_SPY === "true";
 
-  // Helper to forward logs to sandbox
-  const forwardToSandbox = (args) => {
-    const message = args
-      .map((arg) =>
-        typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg),
-      )
-      .join(" ");
+/**
+ * Serialise console args to a single string for sandbox forwarding.
+ * Falls back to toString on circular/huge objects to avoid blowing out the
+ * stack inside JSON.stringify.
+ */
+function serialiseConsoleArgs(args) {
+  return args
+    .map((arg) => {
+      if (typeof arg === "object" && arg !== null) {
+        try {
+          return JSON.stringify(arg, null, 2);
+        } catch {
+          // Circular reference or too deep — fall back safely
+          return String(arg);
+        }
+      }
+      return String(arg);
+    })
+    .join(" ");
+}
 
-    // Send to sandbox for immediate visibility in dashcam
+/**
+ * Forward a console message to every active sandbox client.
+ * Called from the (single) console spy.
+ */
+function forwardToAllSandboxes(args) {
+  if (_consoleSpy.activeClients.size === 0) return;
+
+  const message = serialiseConsoleArgs(args);
+  const encoded = Buffer.from(message, "utf8").toString("base64");
+
+  for (const client of _consoleSpy.activeClients) {
     if (client.sandbox && client.sandbox.instanceSocketConnected) {
       try {
-        client.sandbox.send({
-          type: "output",
-          output: Buffer.from(message, "utf8").toString("base64"),
-        });
-        forwardedCount++;
-        if (debugConsoleSpy && forwardedCount <= 3) {
-          process.stdout.write(
-            `[DEBUG forwardToSandbox] Forwarded message #${forwardedCount}: "${message.substring(0, 50)}..."\n`,
-          );
-        }
-      } catch (err) {
-        if (debugConsoleSpy) {
-          process.stdout.write(
-            `[DEBUG forwardToSandbox] Error sending: ${err.message}\n`,
-          );
-        }
-      }
-    } else {
-      skippedCount++;
-      if (debugConsoleSpy && skippedCount <= 3) {
-        process.stdout.write(
-          `[DEBUG forwardToSandbox] SKIPPED (sandbox not connected): "${message.substring(0, 50)}..."\n`,
-        );
+        client.sandbox.send({ type: "output", output: encoded });
+      } catch {
+        // fire-and-forget — don't let one broken socket block the others
       }
     }
-  };
-
-  // Store original console methods before spying
-  const originalLog = console.log.bind(console);
-  const originalError = console.error.bind(console);
-  const originalWarn = console.warn.bind(console);
-  const originalInfo = console.info.bind(console);
+  }
+}
 
-  // Create spies for each console method
-  const logSpy = vi.spyOn(console, "log").mockImplementation((...args) => {
-    originalLog(...args); // Call original (Vitest will capture this)
-    forwardToSandbox(args);
-  });
+/**
+ * Install the singleton console spy (idempotent).
+ * Must be called *after* Vitest has set up its own console interception so
+ * that the originals we capture are Vitest's wrappers (which feed the test
+ * reporter output).
+ */
+function installConsoleSpy() {
+  if (_consoleSpy.installed) return;
+  _consoleSpy.installed = true;
+
+  // Capture originals once — these are whatever console methods look like
+  // right now (possibly already wrapped by Vitest's own reporter).
+  _consoleSpy.originals = {
+    log: console.log.bind(console),
+    error: console.error.bind(console),
+    warn: console.warn.bind(console),
+    info: console.info.bind(console),
+  };
 
-  const errorSpy = vi.spyOn(console, "error").mockImplementation((...args) => {
-    originalError(...args);
-    forwardToSandbox(args);
-  });
+  const makeHandler = (originalFn) => (...args) => {
+    originalFn(...args);           // Let Vitest's reporter capture the output
+    forwardToAllSandboxes(args);   // Forward to all sandbox dashcam streams
+  };
 
-  const warnSpy = vi.spyOn(console, "warn").mockImplementation((...args) => {
-    originalWarn(...args);
-    forwardToSandbox(args);
-  });
+  _consoleSpy.spies = {
+    log: vi.spyOn(console, "log").mockImplementation(makeHandler(_consoleSpy.originals.log)),
+    error: vi.spyOn(console, "error").mockImplementation(makeHandler(_consoleSpy.originals.error)),
+    warn: vi.spyOn(console, "warn").mockImplementation(makeHandler(_consoleSpy.originals.warn)),
+    info: vi.spyOn(console, "info").mockImplementation(makeHandler(_consoleSpy.originals.info)),
+  };
 
-  const infoSpy = vi.spyOn(console, "info").mockImplementation((...args) => {
-    originalInfo(...args);
-    forwardToSandbox(args);
-  });
+  if (debugConsoleSpy) {
+    process.stdout.write("[DEBUG consoleSpy] Singleton console spy installed\n");
+  }
+}
 
-  // Store spies on client for cleanup
-  client._consoleSpies = { logSpy, errorSpy, warnSpy, infoSpy };
+/**
+ * Register a TestDriver client so its sandbox receives forwarded logs.
+ * @param {import('../../sdk.js').default} client - TestDriver client instance
+ * @param {string} taskId - Unique task identifier (for debug logging)
+ */
+function setupConsoleSpy(client, taskId) {
+  if (debugConsoleSpy) {
+    process.stdout.write(`[DEBUG setupConsoleSpy] registering taskId: ${taskId}\n`);
+  }
+  installConsoleSpy();
+  _consoleSpy.activeClients.add(client);
 }
 
 /**
- * Clean up console spies and restore original console methods
- * @param {TestDriver} client - TestDriver client instance
+ * Unregister a client so its sandbox no longer receives forwarded logs.
+ * When the last client is removed the spy stays installed (harmless) so we
+ * never have to worry about restore-order races with concurrent tests.
+ * @param {import('../../sdk.js').default} client - TestDriver client instance
  */
 function cleanupConsoleSpy(client) {
-  if (client._consoleSpies) {
-    const { logSpy, errorSpy, warnSpy, infoSpy } = client._consoleSpies;
-    logSpy.mockRestore();
-    errorSpy.mockRestore();
-    warnSpy.mockRestore();
-    infoSpy.mockRestore();
-    delete client._consoleSpies;
+  _consoleSpy.activeClients.delete(client);
+  if (debugConsoleSpy) {
+    process.stdout.write(
+      `[DEBUG cleanupConsoleSpy] clients remaining: ${_consoleSpy.activeClients.size}\n`,
+    );
   }
 }
 
@@ -218,7 +237,6 @@ function registerSignalHandlers() {
  * });
  */
 export function TestDriver(context, options = {}) {
-  console.log("[DEBUG hooks entry] options:", JSON.stringify(options));
   if (!context || !context.task) {
     throw new Error(
       'TestDriver() requires Vitest context. Pass the context parameter from your test function: test("name", async (context) => { ... })',
@@ -274,8 +292,6 @@ export function TestDriver(context, options = {}) {
     config.apiRoot = process.env.TD_API_ROOT;
   }
 
-  console.log("[DEBUG hooks] options.preview:", options.preview, "config.preview:", config.preview);
-
   const testdriver = new TestDriverSDK(apiKey, config);
   testdriver.__vitestContext = context.task;
   testdriver._debugOnFailure = mergedOptions.debugOnFailure || false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testdriverai",
-  "version": "7.3.28",
+  "version": "7.3.29",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",