testdriverai 7.0.0 → 7.1.0

package/agent/lib/redraw.js

@@ -3,13 +3,28 @@ const fs = require("fs");
 const { events } = require("../events");
 const theme = require("./theme");
 
+// Default redraw options
+const DEFAULT_REDRAW_OPTIONS = {
+  enabled: true,           // Master switch to enable/disable redraw detection
+  screenRedraw: true,      // Enable screen redraw detection
+  networkMonitor: true,    // Enable network activity monitoring
+  diffThreshold: 0.1,      // Percentage threshold for screen diff (0.1 = 0.1%)
+};
+
 // Factory function that creates redraw functionality with the provided system instance
 const createRedraw = (
   emitter,
   system,
   sandbox,
-  redrawThresholdPercent = 0.1,
+  defaultOptions = {},
 ) => {
+  // Merge default options with provided defaults
+  const baseOptions = { ...DEFAULT_REDRAW_OPTIONS, ...defaultOptions };
+  // Support legacy redrawThresholdPercent number argument
+  if (typeof defaultOptions === 'number') {
+    baseOptions.diffThreshold = defaultOptions;
+  }
+  
   const networkUpdateInterval = 15000;
 
   let lastTxBytes = null;
@@ -116,16 +131,13 @@ const createRedraw = (
         { threshold: 0.1 },
       );
 
-      if (differentPixels === 0) {
-        return false;
-      } else {
-        // Calculate percentage difference based on pixel differences
-        const diffPercentage = (differentPixels / totalPixels) * 100;
-        return diffPercentage.toFixed(1);
-      }
+      // Calculate percentage difference based on pixel differences
+      // Always return a number (0 if no difference)
+      const diffPercentage = (differentPixels / totalPixels) * 100;
+      return parseFloat(diffPercentage.toFixed(2));
     } catch (error) {
       console.error("Error comparing images:", error);
-      return false;
+      return 0; // Return 0 on error instead of false
     }
   }
 
@@ -146,46 +158,104 @@ const createRedraw = (
     }
   }
 
-  async function start() {
+  // Current options for the active redraw cycle
+  let currentOptions = { ...baseOptions };
+
+  async function start(options = {}) {
+    // Merge base options with per-call options
+    currentOptions = { ...baseOptions, ...options };
+    
+    console.log('[redraw] start() called with options:', JSON.stringify(currentOptions));
+    
+    // If redraw is completely disabled, return early
+    if (!currentOptions.enabled) {
+      console.log('[redraw] start() - redraw disabled, returning null');
+      return null;
+    }
+    
+    // If both screenRedraw and networkMonitor are disabled, disable redraw
+    if (!currentOptions.screenRedraw && !currentOptions.networkMonitor) {
+      currentOptions.enabled = false;
+      console.log('[redraw] start() - both screenRedraw and networkMonitor disabled, returning null');
+      return null;
+    }
+    
     resetState();
-    startNetworkMonitoring();
-    startImage = await system.captureScreenPNG(0.25, true);
+    
+    // Only start network monitoring if enabled
+    if (currentOptions.networkMonitor) {
+      startNetworkMonitoring();
+    }
+    
+    // Only capture start image if screen redraw is enabled
+    if (currentOptions.screenRedraw) {
+      startImage = await system.captureScreenPNG(0.25, true);
+      console.log('[redraw] start() - captured startImage:', startImage);
+    }
+    
     return startImage;
   }
 
-  async function checkCondition(resolve, startTime, timeoutMs) {
-    let nowImage = await system.captureScreenPNG(0.25, true);
+  async function checkCondition(resolve, startTime, timeoutMs, options) {
+    const { enabled, screenRedraw, networkMonitor, diffThreshold } = options;
+    
+    // If redraw is disabled, resolve immediately
+    if (!enabled) {
+      resolve("true");
+      return;
+    }
+    
+    let nowImage = screenRedraw ? await system.captureScreenPNG(0.25, true) : null;
     let timeElapsed = Date.now() - startTime;
     let diffPercent = 0;
     let isTimeout = timeElapsed > timeoutMs;
 
-    if (!screenHasRedrawn) {
+    // Check screen redraw if enabled and we have a start image to compare against
+    if (screenRedraw && !screenHasRedrawn && startImage && nowImage) {
+      console.log('[redraw] checkCondition() - comparing images:', { startImage, nowImage });
       diffPercent = await imageDiffPercent(startImage, nowImage);
-      screenHasRedrawn = diffPercent > redrawThresholdPercent;
+      console.log('[redraw] checkCondition() - diffPercent:', diffPercent, 'threshold:', diffThreshold);
+      screenHasRedrawn = diffPercent > diffThreshold;
+      console.log('[redraw] checkCondition() - screenHasRedrawn:', screenHasRedrawn);
+    } else if (screenRedraw && !startImage) {
+      // If no start image was captured, capture one now and wait for next check
+      console.log('[redraw] checkCondition() - no startImage, capturing now');
+      startImage = await system.captureScreenPNG(0.25, true);
     }
-
-    // // log redraw as output
-    let redrawText = screenHasRedrawn
-      ? theme.green(`y`)
-      : theme.dim(`${diffPercent}/${redrawThresholdPercent}%`);
-    let networkText = networkSettled
-      ? theme.green(`y`)
-      : theme.dim(
-          `${Math.trunc((diffRxBytes + diffTxBytes) / networkUpdateInterval)}b/s`,
-        );
+    
+    // If screen redraw is disabled, consider it as "redrawn"
+    const effectiveScreenRedrawn = screenRedraw ? screenHasRedrawn : true;
+    // If network monitor is disabled, consider it as "settled"
+    const effectiveNetworkSettled = networkMonitor ? networkSettled : true;
+
+    // Log redraw status
+    let redrawText = !screenRedraw
+      ? theme.dim(`disabled`)
+      : effectiveScreenRedrawn
+        ? theme.green(`y`)
+        : theme.dim(`${diffPercent}/${diffThreshold}%`);
+    let networkText = !networkMonitor
+      ? theme.dim(`disabled`)
+      : effectiveNetworkSettled
+        ? theme.green(`y`)
+        : theme.dim(
+            `${Math.trunc((diffRxBytes + diffTxBytes) / networkUpdateInterval)}b/s`,
+          );
     let timeoutText = isTimeout
       ? theme.green(`y`)
       : theme.dim(`${Math.floor(timeElapsed / 1000)}/${timeoutMs / 1000}s`);
 
     emitter.emit(events.redraw.status, {
       redraw: {
-        hasRedrawn: screenHasRedrawn,
+        enabled: screenRedraw,
+        hasRedrawn: effectiveScreenRedrawn,
         diffPercent,
-        threshold: redrawThresholdPercent,
+        threshold: diffThreshold,
         text: redrawText,
       },
       network: {
-        settled: networkSettled,
+        enabled: networkMonitor,
+        settled: effectiveNetworkSettled,
         rxBytes: diffRxBytes,
         txBytes: diffTxBytes,
         text: networkText,
@@ -198,27 +268,42 @@ const createRedraw = (
       },
     });
 
-    if ((screenHasRedrawn && networkSettled) || isTimeout) {
+    if ((effectiveScreenRedrawn && effectiveNetworkSettled) || isTimeout) {
       emitter.emit(events.redraw.complete, {
-        screenHasRedrawn,
-        networkSettled,
+        screenHasRedrawn: effectiveScreenRedrawn,
+        networkSettled: effectiveNetworkSettled,
         isTimeout,
         timeElapsed,
       });
       resolve("true");
     } else {
       setTimeout(() => {
-        checkCondition(resolve, startTime, timeoutMs);
+        checkCondition(resolve, startTime, timeoutMs, options);
       }, 500);
     }
   }
 
-  function wait(timeoutMs) {
+  function wait(timeoutMs, options = {}) {
+    // Merge current options with any per-call overrides
+    const waitOptions = { ...currentOptions, ...options };
+    
+    // If redraw is disabled, resolve immediately
+    if (!waitOptions.enabled) {
+      return Promise.resolve("true");
+    }
+    
+    // If both are disabled, resolve immediately
+    if (!waitOptions.screenRedraw && !waitOptions.networkMonitor) {
+      return Promise.resolve("true");
+    }
+    
     return new Promise((resolve) => {
       const startTime = Date.now();
-      // Start network monitoring if not already started
-      startNetworkMonitoring();
-      checkCondition(resolve, startTime, timeoutMs);
+      // Start network monitoring if not already started and enabled
+      if (waitOptions.networkMonitor) {
+        startNetworkMonitoring();
+      }
+      checkCondition(resolve, startTime, timeoutMs, waitOptions);
     });
   }
 
@@ -226,7 +311,7 @@ const createRedraw = (
     stopNetworkMonitoring(networkInterval);
   }
 
-  return { start, wait, cleanup };
+  return { start, wait, cleanup, DEFAULT_OPTIONS: DEFAULT_REDRAW_OPTIONS };
 };
 
-module.exports = { createRedraw };
+module.exports = { createRedraw, DEFAULT_REDRAW_OPTIONS };

package/agent/lib/sandbox.js

@@ -2,7 +2,7 @@ const WebSocket = require("ws");
 const marky = require("marky");
 const { events } = require("../events");
 
-const createSandbox = (emitter, analytics) => {
+const createSandbox = (emitter, analytics, sessionInstance) => {
   class Sandbox {
     constructor() {
       this.socket = null;
@@ -15,6 +15,7 @@ const createSandbox = (emitter, analytics) => {
       this.messageId = 0;
       this.uniqueId = Math.random().toString(36).substring(7);
       this.os = null; // Store OS value to send with every message
+      this.sessionInstance = sessionInstance; // Store session instance to include in messages
     }
 
     send(message) {
@@ -35,6 +36,14 @@ const createSandbox = (emitter, analytics) => {
           message.os = this.os;
         }
 
+        // Add session to every message if available (for interaction tracking)
+        if (this.sessionInstance && !message.session) {
+          const sessionId = this.sessionInstance.get();
+          if (sessionId) {
+            message.session = sessionId;
+          }
+        }
+
         // Start timing for this message
         const timingKey = `sandbox-${message.type}`;
         marky.mark(timingKey);

package/agent/lib/sdk.js

@@ -194,6 +194,27 @@ const createSDK = (emitter, config, sessionInstance) => {
 
       return value;
     } catch (error) {
+      // Check if this is an API validation error with detailed problems
+      if (error.response?.data?.problems) {
+        const problems = error.response.data.problems;
+        const errorMessage = error.response.data.message || 'API validation error';
+        const detailedError = new Error(
+          `${errorMessage}\n\nDetails:\n${problems.map(p => `  - ${p}`).join('\n')}`
+        );
+        detailedError.originalError = error;
+        detailedError.problems = problems;
+        
+        // Emit the formatted error
+        emitter.emit(events.error.sdk, {
+          message: detailedError.message,
+          code: error.response?.data?.code || error.code,
+          problems: problems,
+          fullError: error,
+        });
+        
+        throw detailedError;
+      }
+      
       outputError(error);
       throw error; // Re-throw the error so calling code can handle it properly
     }