testdriverai 7.3.25 → 7.3.27

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [7.3.27](https://github.com/testdriverai/testdriverai/compare/v7.3.25...v7.3.27) (2026-02-20)
+
+
+
+## [7.3.26](https://github.com/testdriverai/testdriverai/compare/v7.3.25...v7.3.26) (2026-02-20)
+
+
+
 ## [7.3.25](https://github.com/testdriverai/testdriverai/compare/v7.3.24...v7.3.25) (2026-02-20)
 
 

package/agent/index.js

@@ -1791,10 +1791,13 @@ ${regression}
         ip: this.ip,
       });
 
-      // Store sandboxId (for self-hosted, use the IP as identifier) so messages include it
-      // This enables the API to reconnect if the websocket connection is rerouted
+      // Store connection params for reconnection
+      // For direct IP connections, store as a direct type so reconnection
+      // sends a 'direct' message instead of 'connect' with an IP as sandboxId
       this.sandbox._lastConnectParams = {
-        sandboxId: instance?.instance?.instanceId || instance?.instance?.sandboxId || this.ip,
+        type: 'direct',
+        ip: this.ip,
+        sandboxId: instance?.instance?.instanceId || instance?.instance?.sandboxId || null,
         persist: true,
         keepAlive: this.keepAlive,
       };

package/agent/lib/sandbox.js

@@ -97,8 +97,13 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
 
         // Add sandboxId to every message if we have a connected sandbox
         // This allows the API to reconnect if the connection was rerouted
+        // Don't inject IP addresses as sandboxId — only valid instance/sandbox IDs
         if (this._lastConnectParams?.sandboxId && !message.sandboxId) {
-          message.sandboxId = this._lastConnectParams.sandboxId;
+          const id = this._lastConnectParams.sandboxId;
+          // Only inject if it looks like a valid ID (not an IP address)
+          if (id && !/^\d+\.\d+\.\d+\.\d+$/.test(id)) {
+            message.sandboxId = id;
+          }
         }
 
         let p = new Promise((resolve, reject) => {
@@ -122,6 +127,11 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
             );
           }
         }, timeout);
+        // Don't let pending message timeouts prevent Node process from exiting
+        // (unref is not available in browser/non-Node environments)
+        if (timeoutId.unref) {
+          timeoutId.unref();
+        }
 
         // Track timeout so close() can clear it
         this.pendingTimeouts.set(requestId, timeoutId);
@@ -210,6 +220,26 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
       }
     }
 
+    /**
+     * Reconnect to a direct IP-based sandbox after connection loss.
+     * Sends a 'direct' message instead of 'connect' to avoid the API
+     * treating the IP as an AWS instance ID.
+     */
+    async reconnectDirect(ip) {
+      let reply = await this.send({
+        type: "direct",
+        ip,
+      });
+
+      if (reply.success) {
+        this.instanceSocketConnected = true;
+        emitter.emit(events.sandbox.connected);
+        return reply;
+      } else {
+        throw new Error(reply.errorMessage || "Failed to reconnect to direct sandbox");
+      }
+    }
+
     async handleConnectionLoss() {
       if (this.intentionalDisconnect) return;
 
@@ -295,9 +325,16 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
           // Without this, the new API instance has no connection.desktop
           // and all Linux operations will fail with "sandbox not initialized"
           if (this._lastConnectParams) {
-            const { sandboxId, persist, keepAlive } = this._lastConnectParams;
-            console.log(`[Sandbox] Re-establishing sandbox connection (${sandboxId})...`);
-            await this.connect(sandboxId, persist, keepAlive);
+            if (this._lastConnectParams.type === 'direct') {
+              // Direct IP connections must reconnect via 'direct' message, not 'connect'
+              const { ip, persist, keepAlive } = this._lastConnectParams;
+              console.log(`[Sandbox] Re-establishing direct connection (${ip})...`);
+              await this.reconnectDirect(ip);
+            } else {
+              const { sandboxId, persist, keepAlive } = this._lastConnectParams;
+              console.log(`[Sandbox] Re-establishing sandbox connection (${sandboxId})...`);
+              await this.connect(sandboxId, persist, keepAlive);
+            }
           }
           console.log("[Sandbox] Reconnected successfully.");
           
@@ -309,6 +346,11 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
           this.reconnecting = false;
         }
       }, delay);
+      // Don't let the reconnect timer prevent Node process from exiting
+      // (unref is not available in browser/non-Node environments)
+      if (this.reconnectTimer.unref) {
+        this.reconnectTimer.unref();
+      }
     }
 
     /**

package/examples/parse.test.mjs

@@ -12,8 +12,8 @@ describe("Parse Test", () => {
     const testdriver = TestDriver(context, { ...getDefaults(context) });
     await testdriver.provision.chrome({ url: "https://www.airbnb.com" });
 
+    // The SDK automatically outputs elements as a formatted table
     const result = await testdriver.parse();
     console.log(`Found ${result.elements?.length || 0} elements`);
-    console.log(JSON.stringify(result, null, 2));
   });
 });

package/lib/vitest/hooks.mjs

@@ -173,6 +173,33 @@ function cleanupConsoleSpy(client) {
 const testDriverInstances = new WeakMap();
 const lifecycleHandlers = new WeakMap();
 
+// Set to track all active TestDriver instances for signal-based cleanup
+const activeInstances = new Set();
+
+// Register signal handlers once to clean up all active instances on forced exit
+let signalHandlersRegistered = false;
+function registerSignalHandlers() {
+  if (signalHandlersRegistered) return;
+  signalHandlersRegistered = true;
+
+  const cleanup = async () => {
+    const instances = Array.from(activeInstances);
+    activeInstances.clear();
+    await Promise.race([
+      Promise.all(instances.map((inst) => inst.disconnect().catch(() => {}))),
+      new Promise((resolve) => setTimeout(resolve, 5000)), // 5s max for cleanup
+    ]);
+  };
+
+  process.on("SIGINT", () => {
+    cleanup().finally(() => process.exit(130));
+  });
+
+  process.on("SIGTERM", () => {
+    cleanup().finally(() => process.exit(143));
+  });
+}
+
 /**
  * Create a TestDriver client in a Vitest test with automatic lifecycle management
  *
@@ -253,6 +280,8 @@ export function TestDriver(context, options = {}) {
   testdriver.__vitestContext = context.task;
   testdriver._debugOnFailure = mergedOptions.debugOnFailure || false;
   testDriverInstances.set(context.task, testdriver);
+  activeInstances.add(testdriver);
+  registerSignalHandlers();
 
   // Set platform metadata early so the reporter can show the correct OS from the start
   if (!context.task.meta) {
@@ -388,6 +417,9 @@ export function TestDriver(context, options = {}) {
       // Clean up console spies
       cleanupConsoleSpy(currentInstance);
 
+      // Remove from active instances tracking (even in debug mode we clean up tracking)
+      activeInstances.delete(currentInstance);
+
       // DO NOT disconnect or terminate - keep sandbox alive for debugging
       return;
     }
@@ -514,6 +546,8 @@ export function TestDriver(context, options = {}) {
     } catch (error) {
       console.error("Error disconnecting client:", error);
     } finally {
+      // Remove from active instances tracking
+      activeInstances.delete(currentInstance);
       // Terminate AWS instance if one was spawned for this test
       // This must happen AFTER dashcam.stop() to ensure recording is saved
       // AND it must happen even if disconnect() fails

package/lib/vitest/setup-aws.mjs

@@ -115,16 +115,16 @@ function cleanupAllInstances() {
 process.on("exit", cleanupAllInstances);
 process.on("SIGINT", () => {
   cleanupAllInstances();
-  // Don't call process.exit here - let the signal handler do its job
+  process.exit(130); // Restore default SIGINT exit behavior (128 + signal 2)
 });
 process.on("SIGTERM", () => {
   cleanupAllInstances();
-  // Don't call process.exit here - let the signal handler do its job
+  process.exit(143); // Restore default SIGTERM exit behavior (128 + signal 15)
 });
 process.on("uncaughtException", (error) => {
   console.error("[TestDriver] Uncaught exception:", error);
   cleanupAllInstances();
-  // Don't call process.exit here - let Node.js handle the exception
+  process.exit(1); // Exit after uncaught exception cleanup
 });
 
 beforeEach(async (context) => {

package/package.json

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

package/sdk-log-formatter.js

@@ -1022,6 +1022,130 @@ class SDKLogFormatter {
     
     return parts.join(" ");
   }
+
+  /**
+   * Format parse() elements as a formatted table for console output 📋
+   * @param {Array} elements - Array of parsed elements from parse()
+   * @param {Object} options - Formatting options
+   * @param {number} options.maxContentLength - Max length for content column (default: 30)
+   * @param {number} options.maxRows - Max number of rows to display (default: 50)
+   * @returns {string} Formatted table string
+   */
+  formatParseElements(elements, options = {}) {
+    if (!elements || elements.length === 0) {
+      return chalk.dim("  No elements found");
+    }
+
+    const maxContentLength = options.maxContentLength || 30;
+    const maxRows = options.maxRows || 50;
+    
+    // Column widths
+    const idxWidth = 5;
+    const typeWidth = 10;
+    const contentWidth = maxContentLength + 2;
+    const interactWidth = 14;
+    const posWidth = 18;
+    
+    const lines = [];
+    
+    // Header
+    const headerLine = [
+      chalk.bold.cyan(this._padRight("Idx", idxWidth)),
+      chalk.bold.cyan(this._padRight("Type", typeWidth)),
+      chalk.bold.cyan(this._padRight("Content", contentWidth)),
+      chalk.bold.cyan(this._padRight("Interactive", interactWidth)),
+      chalk.bold.cyan("Position"),
+    ].join(chalk.dim(" │ "));
+    
+    lines.push("  " + headerLine);
+    
+    // Separator line
+    const separatorLine = [
+      chalk.dim("─".repeat(idxWidth)),
+      chalk.dim("─".repeat(typeWidth)),
+      chalk.dim("─".repeat(contentWidth)),
+      chalk.dim("─".repeat(interactWidth)),
+      chalk.dim("─".repeat(posWidth)),
+    ].join(chalk.dim("─┼─"));
+    
+    lines.push("  " + separatorLine);
+    
+    // Data rows
+    const displayElements = elements.slice(0, maxRows);
+    for (const el of displayElements) {
+      const idx = String(el.index ?? "?");
+      const type = el.type || "unknown";
+      const content = this._truncate(el.content || "", maxContentLength);
+      
+      // Format interactivity with color
+      // Note: interactivity can be boolean (true/false) or string ("clickable", "non-interactive")
+      let interactivity = el.interactivity || "-";
+      let interactivityDisplay;
+      if (interactivity === "clickable" || interactivity === true) {
+        interactivityDisplay = chalk.green("✓ clickable");
+      } else if (interactivity === false || interactivity === "non-interactive") {
+        interactivityDisplay = chalk.dim("-");
+      } else {
+        interactivityDisplay = chalk.dim(String(interactivity));
+      }
+      
+      // Format position from bbox
+      let position = "-";
+      if (el.bbox) {
+        position = `(${el.bbox.x0}, ${el.bbox.y0})`;
+      }
+      
+      // For interactivity column, we need to pad based on visible text, not chalk codes
+      // "✓ clickable" = 11 chars, "-" = 1 char, so we pad manually after getting visible length
+      const interactPadded = this._padRight(interactivityDisplay, interactWidth);
+      
+      const dataLine = [
+        chalk.yellow(this._padRight(idx, idxWidth)),
+        chalk.white(this._padRight(type, typeWidth)),
+        chalk.gray(this._padRight(content, contentWidth)),
+        interactPadded,
+        chalk.dim(position),
+      ].join(chalk.dim(" │ "));
+      
+      lines.push("  " + dataLine);
+    }
+    
+    // Show truncation message if needed
+    if (elements.length > maxRows) {
+      lines.push(chalk.dim(`  ... and ${elements.length - maxRows} more elements (showing first ${maxRows})`));
+    }
+    
+    return lines.join("\n");
+  }
+
+  /**
+   * Truncate a string to a maximum length with ellipsis
+   * @private
+   * @param {string} str - String to truncate
+   * @param {number} maxLength - Maximum length
+   * @returns {string} Truncated string
+   */
+  _truncate(str, maxLength) {
+    if (!str) return "";
+    // Remove newlines and extra whitespace
+    const cleaned = str.replace(/\s+/g, " ").trim();
+    if (cleaned.length <= maxLength) return cleaned;
+    return cleaned.substring(0, maxLength - 1) + "…";
+  }
+
+  /**
+   * Pad a string to the right to a fixed width
+   * @private
+   * @param {string} str - String to pad
+   * @param {number} width - Target width
+   * @returns {string} Padded string
+   */
+  _padRight(str, width) {
+    // Handle chalk strings by getting visible length
+    const visibleStr = String(str).replace(/\x1b\[[0-9;]*m/g, "");
+    const padding = Math.max(0, width - visibleStr.length);
+    return str + " ".repeat(padding);
+  }
 }
 
 // Export singleton instance

package/sdk.js

@@ -3678,6 +3678,12 @@ CAPTCHA_SOLVER_EOF`,
       `✅ Parse complete: ${response.elements?.length || 0} elements detected`,
     );
 
+    // Output elements as a formatted table
+    if (response.elements && response.elements.length > 0) {
+      const tableOutput = formatter.formatParseElements(response.elements);
+      this.emitter.emit(events.log.log, tableOutput);
+    }
+
     return response;
   }