testdriverai 7.1.4 → 7.2.0

package/sdk.js

@@ -289,6 +289,44 @@ class Element {
     return this._found;
   }
 
+  /**
+   * Serialize element to JSON safely (removes circular references)
+   * This is automatically called by JSON.stringify()
+   * @returns {Object} Serializable representation of the element
+   */
+  toJSON() {
+    const result = {
+      description: this.description,
+      coordinates: this.coordinates,
+      found: this._found,
+      threshold: this._threshold,
+      x: this.coordinates?.x,
+      y: this.coordinates?.y,
+    };
+
+    // Include response metadata if available
+    if (this._response) {
+      result.cache = {
+        hit: this._response.cacheHit || this._response.cache_hit || this._response.cached || false,
+        strategy: this._response.cacheStrategy,
+        createdAt: this._response.cacheCreatedAt,
+        diffPercent: this._response.cacheDiffPercent,
+        imageUrl: this._response.cachedImageUrl,
+      };
+      
+      result.similarity = this._response.similarity;
+      result.confidence = this._response.confidence;
+      result.selector = this._response.selector;
+      
+      // Include AI response text if available
+      if (this._response.response?.content?.[0]?.text) {
+        result.aiResponse = this._response.response.content[0].text;
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Find the element on screen
    * @param {string} [newDescription] - Optional new description to search for
@@ -301,7 +339,10 @@ class Element {
       this.description = newDescription;
     }
 
-    const startTime = Date.now();
+    // Capture absolute timestamp at the very start of the command
+    // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+    const absoluteTimestamp = Date.now();
+    const startTime = absoluteTimestamp;
     let response = null;
     let findError = null;
 
@@ -380,8 +421,6 @@ class Element {
 
       const duration = Date.now() - startTime;
 
-      console.log("AI Response Text:", response?.response.content[0]?.text);
-
       if (response && response.coordinates) {
         // Store response but clear large base64 data to prevent memory leaks
         this._response = this._sanitizeResponse(response);
@@ -394,6 +433,14 @@ class Element {
         this._response = this._sanitizeResponse(response);
         this._found = false;
         findError = "Element not found";
+        
+        // Log not found
+        const duration = Date.now() - startTime;
+        const { events } = require("./agent/events.js");
+        const notFoundMessage = formatter.formatElementNotFound(description, {
+          duration: `${duration}ms`,
+        });
+        this.sdk.emitter.emit(events.log.log, notFoundMessage);
       }
     } catch (error) {
       this._response = error.response
@@ -402,27 +449,36 @@ class Element {
       this._found = false;
       findError = error.message;
       response = error.response;
+      
+      // Log not found with error
+      const duration = Date.now() - startTime;
+      const { events } = require("./agent/events.js");
+      const notFoundMessage = formatter.formatElementNotFound(description, {
+        duration: `${duration}ms`,
+        error: error.message,
+      });
+      this.sdk.emitter.emit(events.log.log, notFoundMessage);
+      
+      console.error("Error during find():", error);
     }
 
-    // Track find interaction once at the end
+    // Track find interaction once at the end (fire-and-forget, don't block)
     const sessionId = this.sdk.getSessionId();
     if (sessionId && this.sdk.sandbox?.send) {
-      try {
-        await this.sdk.sandbox.send({
-          type: "trackInteraction",
-          interactionType: "find",
-          session: sessionId,
-          prompt: description,
-          timestamp: startTime,
-          success: this._found,
-          error: findError,
-          cacheHit: response?.cacheHit || response?.cache_hit || response?.cached || false,
-          selector: response?.selector,
-          selectorUsed: !!response?.selector,
-        });
-      } catch (err) {
+      await this.sdk.sandbox.send({
+        type: "trackInteraction",
+        interactionType: "find",
+        session: sessionId,
+        prompt: description,
+        timestamp: absoluteTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+        success: this._found,
+        error: findError,
+        cacheHit: response?.cacheHit || response?.cache_hit || response?.cached || false,
+        selector: response?.selector,
+        selectorUsed: !!response?.selector,
+      }).catch(err => {
         console.warn("Failed to track find interaction:", err.message);
-      }
+      });
     }
 
     return this;
@@ -470,11 +526,15 @@ class Element {
 
     // Emit element found as log:log event
     const { events } = require("./agent/events.js");
+    const Dashcam = require("./lib/core/Dashcam");
+    const consoleUrl = Dashcam.getConsoleUrl(this.sdk.config?.TD_API_ROOT);
     const formattedMessage = formatter.formatElementFound(this.description, {
       x: this.coordinates.x,
       y: this.coordinates.y,
       duration: debugInfo.duration,
       cacheHit: debugInfo.cacheHit,
+      selectorId: this._response?.selector,
+      consoleUrl: consoleUrl,
     });
     this.sdk.emitter.emit(events.log.log, formattedMessage);
 
@@ -1079,7 +1139,6 @@ class TestDriverSDK {
 
     // Store sandbox configuration options
     this.sandboxAmi = options.sandboxAmi || null;
-    this.sandboxOs = options.sandboxOs || null;
     this.sandboxInstance = options.sandboxInstance || null;
 
     // Cache threshold configuration
@@ -1233,26 +1292,18 @@ class TestDriverSDK {
             
             await this.exec(shell, createLogCmd, 10000, true);
           
-          console.log('[provision.chrome] Adding web logs to dashcam...');
-          try {
             const urlObj = new URL(url);
             const domain = urlObj.hostname;
             const pattern = `*${domain}*`;
             await this._dashcam.addWebLog(pattern, 'Web Logs');
-            console.log(`[provision.chrome] ✅ Web logs added to dashcam (pattern: ${pattern})`);
 
             await this._dashcam.addFileLog(logPath, "TestDriver Log");
 
-          } catch (error) {
-            console.warn('[provision.chrome] ⚠️  Failed to add web logs:', error.message);
-          }
         }
         
         // Automatically start dashcam if not already recording
         if (!this._dashcam || !this._dashcam.recording) {
-          console.log('[provision.chrome] Starting dashcam...');
           await this.dashcam.start();
-          console.log('[provision.chrome] ✅ Dashcam started');
         }
 
         // Set up Chrome profile with preferences
@@ -1303,17 +1354,17 @@ class TestDriverSDK {
         
         const prefsJson = JSON.stringify(chromePrefs, null, 2);
         const writePrefCmd = this.os === 'windows'
-          ? `Set-Content -Path "${prefsPath}" -Value '${prefsJson.replace(/'/g, "''")}'`
+          // Use compact JSON and [System.IO.File]::WriteAllText to avoid Set-Content hanging issues
+          ? `[System.IO.File]::WriteAllText("${prefsPath}", '${JSON.stringify(chromePrefs).replace(/'/g, "''")}')`
           : `cat > "${prefsPath}" << 'EOF'\n${prefsJson}\nEOF`;
         
         await this.exec(shell, writePrefCmd, 10000, true);
-        console.log('[provision.chrome] ✅ Chrome preferences configured');
 
         // Build Chrome launch command
         const chromeArgs = [];
         if (maximized) chromeArgs.push('--start-maximized');
         if (guest) chromeArgs.push('--guest');
-        chromeArgs.push('--disable-fre', '--no-default-browser-check', '--no-first-run', '--disable-infobars', `--user-data-dir=${userDataDir}`);
+        chromeArgs.push('--disable-fre', '--no-default-browser-check', '--no-first-run', '--no-experiments', '--disable-infobars', `--user-data-dir=${userDataDir}`);
         
         // Add dashcam-chrome extension on Linux
         if (this.os === 'linux') {
@@ -1341,30 +1392,305 @@ class TestDriverSDK {
         // Wait for Chrome to be ready
         await this.focusApplication('Google Chrome');
 
-
         // Wait for URL to load
         try {
           const urlObj = new URL(url);
           const domain = urlObj.hostname;
+                    
+          for (let attempt = 0; attempt < 30; attempt++) {
+            const result = await this.find(`${domain}`);
+
+            if (result.found()) {
+              break;
+            } else {
+              await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+          }
           
-          console.log(`[provision.chrome] Waiting for domain "${domain}" to appear in URL bar...`);
+          await this.focusApplication('Google Chrome');
+        } catch (e) {
+          console.warn(`[provision.chrome] ⚠️  Could not parse URL "${url}":`, e.message);
+        }
+      },
+
+      /**
+       * Launch Chrome browser with a custom extension loaded
+       * @param {Object} options - Chrome extension launch options
+       * @param {string} [options.extensionPath] - Local filesystem path to the unpacked extension directory
+       * @param {string} [options.extensionId] - Chrome Web Store extension ID (e.g., "cjpalhdlnbpafiamejdnhcphjbkeiagm" for uBlock Origin)
+       * @param {string} [options.url='http://testdriver-sandbox.vercel.app/'] - URL to navigate to
+       * @param {boolean} [options.maximized=true] - Start maximized
+       * @returns {Promise<void>}
+       * @example
+       * // Load extension from local path
+       * await testdriver.exec('sh', 'git clone https://github.com/user/extension.git /tmp/extension');
+       * await testdriver.provision.chromeExtension({
+       *   extensionPath: '/tmp/extension',
+       *   url: 'https://example.com'
+       * });
+       * 
+       * @example
+       * // Load extension by Chrome Web Store ID
+       * await testdriver.provision.chromeExtension({
+       *   extensionId: 'cjpalhdlnbpafiamejdnhcphjbkeiagm', // uBlock Origin
+       *   url: 'https://example.com'
+       * });
+       */
+      chromeExtension: async (options = {}) => {
+        // Automatically wait for connection to be ready
+        await this.ready();
+        
+        const {
+          extensionPath: providedExtensionPath,
+          extensionId,
+          url = 'http://testdriver-sandbox.vercel.app/',
+          maximized = true,
+        } = options;
+
+        if (!providedExtensionPath && !extensionId) {
+          throw new Error('[provision.chromeExtension] Either extensionPath or extensionId is required');
+        }
+
+        let extensionPath = providedExtensionPath;
+        const shell = this.os === 'windows' ? 'pwsh' : 'sh';
+
+        // If extensionId is provided, download and extract the extension from Chrome Web Store
+        if (extensionId && !extensionPath) {
+          console.log(`[provision.chromeExtension] Downloading extension ${extensionId} from Chrome Web Store...`);
+          
+          const extensionDir = this.os === 'windows'
+            ? `C:\\Users\\testdriver\\AppData\\Local\\TestDriver\\Extensions\\${extensionId}`
+            : `/tmp/testdriver-extensions/${extensionId}`;
+          
+          // Create extension directory
+          const mkdirCmd = this.os === 'windows'
+            ? `New-Item -ItemType Directory -Path "${extensionDir}" -Force | Out-Null`
+            : `mkdir -p "${extensionDir}"`;
+          await this.exec(shell, mkdirCmd, 10000, true);
+          
+          // Download CRX from Chrome Web Store
+          // The CRX download URL format for Chrome Web Store
+          const crxUrl = `https://clients2.google.com/service/update2/crx?response=redirect&prodversion=131.0.0.0&acceptformat=crx2,crx3&x=id%3D${extensionId}%26installsource%3Dondemand%26uc`;
+          const crxPath = this.os === 'windows'
+            ? `${extensionDir}\\extension.crx`
+            : `${extensionDir}/extension.crx`;
+          
+          if (this.os === 'windows') {
+            await this.exec(
+              'pwsh',
+              `Invoke-WebRequest -Uri "${crxUrl}" -OutFile "${crxPath}"`,
+              60000,
+              true
+            );
+          } else {
+            await this.exec(
+              'sh',
+              `curl -L -o "${crxPath}" "${crxUrl}"`,
+              60000,
+              true
+            );
+          }
+          
+          // Extract the CRX file (CRX is a ZIP with a header)
+          // Skip the CRX header and extract as ZIP
+          if (this.os === 'windows') {
+            // PowerShell: Read CRX, skip header, extract ZIP
+            await this.exec(
+              'pwsh',
+              `
+$crxBytes = [System.IO.File]::ReadAllBytes("${crxPath}")
+# CRX3 header: 4 bytes magic + 4 bytes version + 4 bytes header length + header
+$magic = [System.Text.Encoding]::ASCII.GetString($crxBytes[0..3])
+if ($magic -eq "Cr24") {
+  $headerLen = [BitConverter]::ToUInt32($crxBytes, 8)
+  $zipStart = 12 + $headerLen
+} else {
+  # CRX2 format
+  $zipStart = 16 + [BitConverter]::ToUInt32($crxBytes, 8) + [BitConverter]::ToUInt32($crxBytes, 12)
+}
+$zipBytes = $crxBytes[$zipStart..($crxBytes.Length - 1)]
+$zipPath = "${extensionDir}\\extension.zip"
+[System.IO.File]::WriteAllBytes($zipPath, $zipBytes)
+Expand-Archive -Path $zipPath -DestinationPath "${extensionDir}\\unpacked" -Force
+              `,
+              30000,
+              true
+            );
+            extensionPath = `${extensionDir}\\unpacked`;
+          } else {
+            // Linux: Use unzip with offset or python to extract
+            await this.exec(
+              'sh',
+              `
+cd "${extensionDir}"
+# Extract CRX (skip header and unzip)
+# CRX3 format: magic(4) + version(4) + header_length(4) + header + zip
+python3 -c "
+import struct
+import zipfile
+import io
+import os
+
+with open('extension.crx', 'rb') as f:
+    data = f.read()
+
+# Check magic number
+magic = data[:4]
+if magic == b'Cr24':
+    # CRX3 format
+    header_len = struct.unpack('<I', data[8:12])[0]
+    zip_start = 12 + header_len
+else:
+    # CRX2 format  
+    pub_key_len = struct.unpack('<I', data[8:12])[0]
+    sig_len = struct.unpack('<I', data[12:16])[0]
+    zip_start = 16 + pub_key_len + sig_len
+
+zip_data = data[zip_start:]
+os.makedirs('unpacked', exist_ok=True)
+with zipfile.ZipFile(io.BytesIO(zip_data)) as zf:
+    zf.extractall('unpacked')
+"
+              `,
+              30000,
+              true
+            );
+            extensionPath = `${extensionDir}/unpacked`;
+          }
           
+          console.log(`[provision.chromeExtension] Extension ${extensionId} extracted to ${extensionPath}`);
+        }
+
+        // If dashcam is available and recording, add web logs for this domain
+        if (this._dashcam) {
+          // Create the log file on the remote machine
+          const logPath = this.os === "windows" 
+            ? "C:\\Users\\testdriver\\Documents\\testdriver.log"
+            : "/tmp/testdriver.log";
+          
+          const createLogCmd = this.os === "windows"
+            ? `New-Item -ItemType File -Path "${logPath}" -Force | Out-Null`
+            : `touch ${logPath}`;
+          
+          await this.exec(shell, createLogCmd, 10000, true);
+        
+          const urlObj = new URL(url);
+          const domain = urlObj.hostname;
+          const pattern = `*${domain}*`;
+          await this._dashcam.addWebLog(pattern, 'Web Logs');
+          await this._dashcam.addFileLog(logPath, "TestDriver Log");
+        }
+        
+        // Automatically start dashcam if not already recording
+        if (!this._dashcam || !this._dashcam.recording) {
+          await this.dashcam.start();
+        }
+
+        // Set up Chrome profile with preferences
+        const userDataDir = this.os === 'windows' 
+          ? 'C:\\Users\\testdriver\\AppData\\Local\\TestDriver\\Chrome'
+          : '/tmp/testdriver-chrome-profile';
+        
+        // Create user data directory and Default profile directory
+        const defaultProfileDir = this.os === 'windows'
+          ? `${userDataDir}\\Default`
+          : `${userDataDir}/Default`;
+        
+        const createDirCmd = this.os === 'windows'
+          ? `New-Item -ItemType Directory -Path "${defaultProfileDir}" -Force | Out-Null`
+          : `mkdir -p "${defaultProfileDir}"`;
+        
+        await this.exec(shell, createDirCmd, 10000, true);
+        
+        // Write Chrome preferences
+        const chromePrefs = {
+          credentials_enable_service: false,
+          profile: {
+            password_manager_enabled: false,
+            default_content_setting_values: {}
+          },
+          signin: {
+            allowed: false
+          },
+          sync: {
+            requested: false,
+            first_setup_complete: true,
+            sync_all_os_types: false
+          },
+          autofill: {
+            enabled: false
+          },
+          local_state: {
+            browser: {
+              has_seen_welcome_page: true
+            }
+          }
+        };
+        
+        const prefsPath = this.os === 'windows'
+          ? `${defaultProfileDir}\\Preferences`
+          : `${defaultProfileDir}/Preferences`;
+        
+        const prefsJson = JSON.stringify(chromePrefs, null, 2);
+        const writePrefCmd = this.os === 'windows'
+          // Use compact JSON and [System.IO.File]::WriteAllText to avoid Set-Content hanging issues
+          ? `[System.IO.File]::WriteAllText("${prefsPath}", '${JSON.stringify(chromePrefs).replace(/'/g, "''")}')`
+          : `cat > "${prefsPath}" << 'EOF'\n${prefsJson}\nEOF`;
+        
+        await this.exec(shell, writePrefCmd, 10000, true);
+
+        // Build Chrome launch command
+        const chromeArgs = [];
+        if (maximized) chromeArgs.push('--start-maximized');
+        chromeArgs.push('--disable-fre', '--no-default-browser-check', '--no-first-run', '--no-experiments', '--disable-infobars', '--disable-features=ChromeLabs', `--user-data-dir=${userDataDir}`);
+        
+        // Add user extension and dashcam-chrome extension
+        if (this.os === 'linux') {
+          // Load both user extension and dashcam-chrome for web log capture
+          chromeArgs.push(`--load-extension=${extensionPath},/usr/lib/node_modules/dashcam-chrome/build`);
+        } else if (this.os === 'windows') {
+          // On Windows, just load the user extension (dashcam-chrome not available)
+          chromeArgs.push(`--load-extension=${extensionPath}`);
+        }
+
+        // Launch Chrome
+        if (this.os === 'windows') {
+          const argsString = chromeArgs.map(arg => `"${arg}"`).join(', ');
+          await this.exec(
+            shell,
+            `Start-Process "C:/Program Files/Google/Chrome/Application/chrome.exe" -ArgumentList ${argsString}, "${url}"`,
+            30000
+          );
+        } else {
+          const argsString = chromeArgs.join(' ');
+          await this.exec(
+            shell,
+            `chrome-for-testing ${argsString} "${url}" >/dev/null 2>&1 &`,
+            30000
+          );
+        }
+
+        // Wait for Chrome to be ready
+        await this.focusApplication('Google Chrome');
+
+        // Wait for URL to load
+        try {
+          const urlObj = new URL(url);
+          const domain = urlObj.hostname;
+                    
           for (let attempt = 0; attempt < 30; attempt++) {
-            try {
-              const result = await this.find(`${domain}`);
-              if (result.found()) {
-                console.log(`[provision.chrome] ✅ Chrome ready at ${url}`);
-                break;
-              }
-            } catch (e) {
-              // Not found yet, continue polling
+            const result = await this.find(`${domain}`);
+
+            if (result.found()) {
+              break;
+            } else {
+              await new Promise(resolve => setTimeout(resolve, 1000));
             }
-            await new Promise(resolve => setTimeout(resolve, 1000));
           }
           
           await this.focusApplication('Google Chrome');
         } catch (e) {
-          console.warn(`[provision.chrome] ⚠️  Could not parse URL "${url}":`, e.message);
+          console.warn(`[provision.chromeExtension] ⚠️  Could not parse URL "${url}":`, e.message);
         }
       },
 
@@ -1414,7 +1740,6 @@ class TestDriverSDK {
 
         // Wait for VS Code to be ready
         await this.focusApplication('Visual Studio Code');
-        console.log('[provision.vscode] ✅ VS Code ready');
       },
 
       /**
@@ -1451,7 +1776,6 @@ class TestDriverSDK {
         }
 
         await this.focusApplication('Electron');
-        console.log('[provision.electron] ✅ Electron app ready');
       },
     };
   }
@@ -1534,13 +1858,11 @@ class TestDriverSDK {
     } else if (this.sandboxInstance) {
       this.agent.sandboxInstance = this.sandboxInstance;
     }
-    // Use os from connectOptions if provided, otherwise fall back to constructor value
+    // Use os from connectOptions if provided, otherwise fall back to this.os
     if (connectOptions.os !== undefined) {
       this.agent.sandboxOs = connectOptions.os;
-    } else if (this.sandboxOs) {
-      this.agent.sandboxOs = this.sandboxOs;
+      this.os = connectOptions.os; // Update this.os to match
     } else {
-      // Fall back to this.os (which defaults to "linux")
       this.agent.sandboxOs = this.os;
     }
 
@@ -1553,6 +1875,17 @@ class TestDriverSDK {
     // Get the instance from the agent
     this.instance = this.agent.instance;
 
+    // Ensure this.os reflects the actual sandbox OS (important for vitest reporter)
+    // After buildEnv, agent.sandboxOs should contain the correct OS value
+    if (this.agent.sandboxOs) {
+      this.os = this.agent.sandboxOs;
+    }
+    
+    // Also ensure sandbox.os is set for consistency
+    if (this.agent.sandbox && this.os) {
+      this.agent.sandbox.os = this.os;
+    }
+
     // Expose the agent's commands, parser, and commander
     this.commands = this.agent.commands;
 
@@ -1689,7 +2022,10 @@ class TestDriverSDK {
   async findAll(description, options) {
     this._ensureConnected();
 
-    const startTime = Date.now();
+    // Capture absolute timestamp at the very start of the command
+    // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+    const absoluteTimestamp = Date.now();
+    const startTime = absoluteTimestamp;
 
     // Log finding all action
     const { events } = require("./agent/events.js");
@@ -1798,25 +2134,23 @@ class TestDriverSDK {
           return element;
         });
 
-        // Track successful findAll interaction
+        // Track successful findAll interaction (fire-and-forget, don't block)
         const sessionId = this.getSessionId();
         if (sessionId && this.sandbox?.send) {
-          try {
-            await this.sandbox.send({
-              type: "trackInteraction",
-              interactionType: "findAll",
-              session: sessionId,
-              prompt: description,
-              timestamp: startTime,
-              success: true,
-              input: { count: elements.length },
-              cacheHit: response.cached || false,
-              selector: response.selector,
-              selectorUsed: !!response.selector,
-            });
-          } catch (err) {
+          this.sandbox.send({
+            type: "trackInteraction",
+            interactionType: "findAll",
+            session: sessionId,
+            prompt: description,
+            timestamp: absoluteTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+            success: true,
+            input: { count: elements.length },
+            cacheHit: response.cached || false,
+            selector: response.selector,
+            selectorUsed: !!response.selector,
+          }).catch(err => {
             console.warn("Failed to track findAll interaction:", err.message);
-          }
+          });
         }
 
         // Log debug information when elements are found
@@ -1835,49 +2169,45 @@ class TestDriverSDK {
 
         return elements;
       } else {
-        // No elements found - track interaction
+        // No elements found - track interaction (fire-and-forget, don't block)
         const sessionId = this.getSessionId();
         if (sessionId && this.sandbox?.send) {
-          try {
-            await this.sandbox.send({
-              type: "trackInteraction",
-              interactionType: "findAll",
-              session: sessionId,
-              prompt: description,
-              timestamp: startTime,
-              success: false,
-              error: "No elements found",
-              input: { count: 0 },
-              cacheHit: response?.cached || false,
-              selector: response?.selector,
-              selectorUsed: !!response?.selector,
-            });
-          } catch (err) {
+          this.sandbox.send({
+            type: "trackInteraction",
+            interactionType: "findAll",
+            session: sessionId,
+            prompt: description,
+            timestamp: absoluteTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+            success: false,
+            error: "No elements found",
+            input: { count: 0 },
+            cacheHit: response?.cached || false,
+            selector: response?.selector,
+            selectorUsed: !!response?.selector,
+          }).catch(err => {
             console.warn("Failed to track findAll interaction:", err.message);
-          }
+          });
         }
 
         // No elements found - return empty array
         return [];
       }
     } catch (error) {
-      // Track findAll error interaction
+      // Track findAll error interaction (fire-and-forget, don't block)
       const sessionId = this.getSessionId();
       if (sessionId && this.sandbox?.send) {
-        try {
-          await this.sandbox.send({
-            type: "trackInteraction",
-            interactionType: "findAll",
-            session: sessionId,
-            prompt: description,
-            timestamp: startTime,
-            success: false,
-            error: error.message,
-            input: { count: 0 },
-          });
-        } catch (err) {
+        this.sandbox.send({
+          type: "trackInteraction",
+          interactionType: "findAll",
+          session: sessionId,
+          prompt: description,
+          timestamp: absoluteTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+          success: false,
+          error: error.message,
+          input: { count: 0 },
+        }).catch(err => {
           console.warn("Failed to track findAll interaction:", err.message);
-        }
+        });
       }
 
       const { events } = require("./agent/events.js");
@@ -2270,6 +2600,7 @@ class TestDriverSDK {
   _setupLogging() {
     // Track the last fatal error message to throw on exit
     let lastFatalError = null;
+    const debugMode = process.env.VERBOSE || process.env.DEBUG || process.env.TD_DEBUG;
 
     // Set up markdown logger
     createMarkdownLogger(this.emitter);
@@ -2277,7 +2608,7 @@ class TestDriverSDK {
     // Set up basic event logging
     this.emitter.on("log:**", (message) => {
       const event = this.emitter.event;
-      if (event === events.log.debug) return;
+      if (event === events.log.debug && !debugMode) return;
       if (this.loggingEnabled && message) {
         const prefixedMessage = this.testContext
           ? `[${this.testContext}] ${message}`
@@ -2307,23 +2638,6 @@ class TestDriverSDK {
       }
     });
 
-    // Handle redraw status for debugging scroll and other async operations
-    this.emitter.on("redraw:status", (status) => {
-      if (this.loggingEnabled) {
-        console.log(
-          `[redraw] screen:${status.redraw.text} network:${status.network.text} timeout:${status.timeout.text}`,
-        );
-      }
-    });
-
-    this.emitter.on("redraw:complete", (info) => {
-      if (this.loggingEnabled) {
-        console.log(
-          `[redraw complete] screen:${info.screenHasRedrawn} network:${info.networkSettled} timeout:${info.isTimeout} elapsed:${info.timeElapsed}ms`,
-        );
-      }
-    });
-
     // Handle exit events - throw error with meaningful message instead of calling process.exit
     // This allows test frameworks like Vitest to properly catch and display the error
     this.emitter.on(events.exit, (exitCode) => {
@@ -2341,7 +2655,7 @@ class TestDriverSDK {
     this.emitter.on("show-window", async (url) => {
       if (this.loggingEnabled) {
         console.log("");
-        console.log("Live test execution:");
+        console.log("🔗 Live test execution:");
         if (this.config.CI) {
           // In CI mode, just print the view-only URL
           const u = new URL(url);
@@ -2356,6 +2670,7 @@ class TestDriverSDK {
           console.log(url);
           await this._openBrowser(url);
         }
+        
       }
     });
   }