testdriverai 7.3.43 → 7.4.0

package/agent/lib/commands.js

@@ -137,6 +137,54 @@ const createCommands = (
   
   const delay = (t) => new Promise((resolve) => setTimeout(resolve, t));
 
+  /**
+   * Track an interaction via HTTP API (fire-and-forget)
+   * @param {Object} data - Interaction data
+   * @param {string} data.interactionType - Type of interaction (click, type, assert, etc.)
+   * @param {string} [data.prompt] - Description/prompt for the interaction
+   * @param {Object} [data.input] - Input data (varies by interaction type)
+   * @param {Object} [data.coordinates] - Coordinates {x, y}
+   * @param {number} data.timestamp - Absolute epoch timestamp
+   * @param {number} [data.duration] - Duration in ms
+   * @param {boolean} data.success - Whether the interaction succeeded
+   * @param {string} [data.error] - Error message if failed
+   * @param {boolean} [data.cacheHit] - Whether cache was used
+   * @param {string} [data.selector] - Selector ID
+   * @param {boolean} [data.selectorUsed] - Whether selector was used
+   * @param {number} [data.confidence] - AI confidence score
+   * @param {string} [data.reasoning] - AI reasoning
+   * @param {number} [data.similarity] - Cache similarity score
+   * @param {string} [data.screenshotUrl] - S3 key for screenshot
+   * @param {boolean} [data.isSecret] - Whether interaction contains sensitive data
+   */
+  const trackInteraction = (data) => {
+    const sessionId = sessionInstance?.get();
+    if (!sessionId) return;
+
+    sdk.req("/api/v7.0.0/testdriver/interaction/track", {
+      session: sessionId,
+      type: data.interactionType,
+      coordinates: data.coordinates,
+      input: data.input,
+      prompt: data.prompt,
+      selectorUsed: data.selectorUsed,
+      selector: data.selector,
+      cacheHit: data.cacheHit,
+      status: "completed",
+      success: data.success,
+      error: data.error,
+      duration: data.duration,
+      timestamp: data.timestamp,
+      isSecret: data.isSecret,
+      confidence: data.confidence,
+      reasoning: data.reasoning,
+      similarity: data.similarity,
+      screenshotUrl: data.screenshotUrl,
+    }).catch((err) => {
+      console.warn(`Failed to track ${data.interactionType} interaction:`, err.message);
+    });
+  };
+
   const findImageOnScreen = async (
     relativePath,
     haystack,
@@ -296,26 +344,19 @@ const createCommands = (
     emitter.emit(events.log.narration, formatter.formatAssertResult(passed, responseText, assertDuration, cacheHit), true);
     
     // Track interaction with success/failure (fire-and-forget)
-    const sessionId = sessionInstance?.get();
-    if (sessionId) {
-      sandbox.send({
-        type: "trackInteraction",
-        interactionType: "assert",
-        session: sessionId,
-        prompt: assertion,
-        timestamp: assertTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-        duration: assertDuration,
-        success: passed,
-        error: passed ? undefined : responseText,
-        cacheHit: cacheHit,
-        confidence: confidence,
-        reasoning: reasoning,
-        similarity: similarity,
-        screenshotUrl: response?.screenshotKey ?? null,
-      }).catch((err) => {
-        console.warn("Failed to track assert interaction:", err.message);
-      });
-    }
+    trackInteraction({
+      interactionType: "assert",
+      prompt: assertion,
+      timestamp: assertTimestamp,
+      duration: assertDuration,
+      success: passed,
+      error: passed ? undefined : responseText,
+      cacheHit: cacheHit,
+      confidence: confidence,
+      reasoning: reasoning,
+      similarity: similarity,
+      screenshotUrl: response?.screenshotKey ?? null,
+    });
     
     if (passed) {
       return true;
@@ -430,40 +471,26 @@ const createCommands = (
       );
       
       // Track interaction success (fire-and-forget)
-      const sessionId = sessionInstance?.get();
-      if (sessionId) {
-        const scrollDuration = Date.now() - scrollStartTime;
-        sandbox.send({
-          type: "trackInteraction",
-          interactionType: "scroll",
-          session: sessionId,
-          input: { direction, amount },
-          timestamp: scrollTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-          duration: scrollDuration,
-          success: scrollSuccess,
-          error: scrollError,
-        }).catch((err) => {
-          console.warn("Failed to track scroll interaction:", err.message);
-        });
-      }
+      const scrollDuration = Date.now() - scrollStartTime;
+      trackInteraction({
+        interactionType: "scroll",
+        input: { direction, amount },
+        timestamp: scrollTimestamp,
+        duration: scrollDuration,
+        success: scrollSuccess,
+        error: scrollError,
+      });
     } catch (error) {
       // Track interaction failure (fire-and-forget)
-      const sessionId = sessionInstance?.get();
-      if (sessionId) {
-        const scrollDuration = Date.now() - scrollStartTime;
-        sandbox.send({
-          type: "trackInteraction",
-          interactionType: "scroll",
-          session: sessionId,
-          input: { direction, amount },
-          timestamp: scrollTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-          duration: scrollDuration,
-          success: false,
-          error: error.message,
-        }).catch((err) => {
-          console.warn("Failed to track scroll interaction:", err.message);
-        });
-      }
+      const scrollDuration = Date.now() - scrollStartTime;
+      trackInteraction({
+        interactionType: "scroll",
+        input: { direction, amount },
+        timestamp: scrollTimestamp,
+        duration: scrollDuration,
+        success: false,
+        error: error.message,
+      });
       throw error;
     }
   };
@@ -575,15 +602,12 @@ const createCommands = (
         const actionDuration = actionEndTime - clickStartTime;
         
         // Track interaction (fire-and-forget)
-        const sessionId = sessionInstance?.get();
-        if (sessionId && elementData.prompt) {
-          sandbox.send({
-            type: "trackInteraction",
+        if (elementData.prompt) {
+          trackInteraction({
             interactionType: "click",
-            session: sessionId,
             prompt: elementData.prompt,
             input: { x, y, action },
-            timestamp: clickTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+            timestamp: clickTimestamp,
             duration: actionDuration,
             success: true,
             cacheHit: elementData.cacheHit,
@@ -593,8 +617,6 @@ const createCommands = (
             reasoning: elementData.reasoning ?? null,
             similarity: elementData.similarity ?? null,
             screenshotUrl: elementData.screenshotUrl ?? null,
-          }).catch((err) => {
-            console.warn("Failed to track click interaction:", err.message);
           });
         }
         
@@ -627,16 +649,13 @@ const createCommands = (
       return;
     } catch (error) {
       // Track interaction failure (fire-and-forget)
-      const sessionId = sessionInstance?.get();
-      if (sessionId && elementData.prompt) {
+      if (elementData.prompt) {
         const clickDuration = Date.now() - clickStartTime;
-        sandbox.send({
-          type: "trackInteraction",
+        trackInteraction({
           interactionType: "click",
-          session: sessionId,
           prompt: elementData.prompt,
           input: { x, y, action },
-          timestamp: clickTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+          timestamp: clickTimestamp,
           duration: clickDuration,
           success: false,
           error: error.message,
@@ -646,8 +665,6 @@ const createCommands = (
           confidence: elementData.confidence ?? null,
           reasoning: elementData.reasoning ?? null,
           similarity: elementData.similarity ?? null,
-        }).catch((err) => {
-          console.warn("Failed to track click interaction:", err.message);
         });
       }
       throw error;
@@ -698,18 +715,15 @@ const createCommands = (
       await sandbox.send({ type: "moveMouse", x, y, ...elementData });
 
       // Track interaction (fire-and-forget)
-      const sessionId = sessionInstance?.get();
       const actionEndTime = Date.now();
       const actionDuration = actionEndTime - hoverStartTime;
       
-      if (sessionId && elementData.prompt) {
-        sandbox.send({
-          type: "trackInteraction",
+      if (elementData.prompt) {
+        trackInteraction({
           interactionType: "hover",
-          session: sessionId,
           prompt: elementData.prompt,
           input: { x, y },
-          timestamp: hoverTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+          timestamp: hoverTimestamp,
           duration: actionDuration,
           success: true,
           cacheHit: elementData.cacheHit,
@@ -719,8 +733,6 @@ const createCommands = (
           reasoning: elementData.reasoning ?? null,
           similarity: elementData.similarity ?? null,
           screenshotUrl: elementData.screenshotUrl ?? null,
-        }).catch((err) => {
-          console.warn("Failed to track hover interaction:", err.message);
         });
       }
 
@@ -741,16 +753,13 @@ const createCommands = (
       return;
     } catch (error) {
       // Track interaction failure (fire-and-forget)
-      const sessionId = sessionInstance?.get();
-      if (sessionId && elementData.prompt) {
+      if (elementData.prompt) {
         const hoverDuration = Date.now() - hoverStartTime;
-        sandbox.send({
-          type: "trackInteraction",
+        trackInteraction({
           interactionType: "hover",
-          session: sessionId,
           prompt: elementData.prompt,
           input: { x, y },
-          timestamp: hoverTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+          timestamp: hoverTimestamp,
           duration: hoverDuration,
           success: false,
           error: error.message,
@@ -761,8 +770,6 @@ const createCommands = (
           reasoning: elementData.reasoning ?? null,
           similarity: elementData.similarity ?? null,
           screenshotUrl: elementData.screenshotUrl ?? null,
-        }).catch((err) => {
-          console.warn("Failed to track hover interaction:", err.message);
         });
       }
       throw error;
@@ -963,23 +970,16 @@ const createCommands = (
       emitter.emit(events.log.narration, formatter.formatTypeResult(text, secret, typeActionEndTime - typeStartTime), true);
       
       // Track interaction (fire-and-forget)
-      const sessionId = sessionInstance?.get();
-      if (sessionId) {
-        const typeDuration = Date.now() - typeStartTime;
-        sandbox.send({
-          type: "trackInteraction",
-          interactionType: "type",
-          session: sessionId,
-          // Store masked text if secret, otherwise store actual text
-          input: { text: secret ? "****" : text, delay },
-          timestamp: typeTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-          duration: typeDuration,
-          success: true,
-          isSecret: secret, // Flag this interaction if it contains a secret
-        }).catch((err) => {
-          console.warn("Failed to track type interaction:", err.message);
-        });
-      }
+      const typeDuration = Date.now() - typeStartTime;
+      trackInteraction({
+        interactionType: "type",
+        // Store masked text if secret, otherwise store actual text
+        input: { text: secret ? "****" : text, delay },
+        timestamp: typeTimestamp,
+        duration: typeDuration,
+        success: true,
+        isSecret: secret, // Flag this interaction if it contains a secret
+      });
       
       const redrawStartTime = Date.now();
       await redraw.wait(5000, redrawOptions);
@@ -1036,21 +1036,14 @@ const createCommands = (
       );
       
       // Track interaction (fire-and-forget)
-      const sessionId = sessionInstance?.get();
-      if (sessionId) {
-        const pressKeysDuration = Date.now() - pressKeysStartTime;
-        sandbox.send({
-          type: "trackInteraction",
-          interactionType: "pressKeys",
-          session: sessionId,
-          input: { keys },
-          timestamp: pressKeysTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-          duration: pressKeysDuration,
-          success: true,
-        }).catch((err) => {
-          console.warn("Failed to track pressKeys interaction:", err.message);
-        });
-      }
+      const pressKeysDuration = Date.now() - pressKeysStartTime;
+      trackInteraction({
+        interactionType: "pressKeys",
+        input: { keys },
+        timestamp: pressKeysTimestamp,
+        duration: pressKeysDuration,
+        success: true,
+      });
 
       const redrawStartTime = Date.now();
       await redraw.wait(5000, redrawOptions);
@@ -1079,21 +1072,14 @@ const createCommands = (
       const result = await delay(timeout);
       
       // Track interaction (fire-and-forget)
-      const sessionId = sessionInstance?.get();
-      if (sessionId) {
-        const waitDuration = Date.now() - waitStartTime;
-        sandbox.send({
-          type: "trackInteraction",
-          interactionType: "wait",
-          session: sessionId,
-          input: { timeout },
-          timestamp: waitTimestamp, // Use dashcam elapsed time instead of absolute time
-          duration: waitDuration,
-          success: true,
-        }).catch((err) => {
-          console.warn("Failed to track wait interaction:", err.message);
-        });
-      }
+      const waitDuration = Date.now() - waitStartTime;
+      trackInteraction({
+        interactionType: "wait",
+        input: { timeout },
+        timestamp: waitTimestamp,
+        duration: waitDuration,
+        success: true,
+      });
       
       return result;
     },
@@ -1158,44 +1144,30 @@ const createCommands = (
         );
         
         // Track interaction success (fire-and-forget)
-        const sessionId = sessionInstance?.get();
-        if (sessionId) {
-          const waitForImageDuration = Date.now() - startTime;
-          sandbox.send({
-            type: "trackInteraction",
-            interactionType: "waitForImage",
-            session: sessionId,
-            prompt: description,
-            input: { timeout },
-            timestamp: waitForImageTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-            duration: waitForImageDuration,
-            success: true,
-          }).catch((err) => {
-            console.warn("Failed to track waitForImage interaction:", err.message);
-          });
-        }
+        const waitForImageDuration = Date.now() - startTime;
+        trackInteraction({
+          interactionType: "waitForImage",
+          prompt: description,
+          input: { timeout },
+          timestamp: waitForImageTimestamp,
+          duration: waitForImageDuration,
+          success: true,
+        });
         
         return;
       } else {
         // Track interaction failure (fire-and-forget)
-        const sessionId = sessionInstance?.get();
         const errorMsg = `Timed out (${niceSeconds(timeout)} seconds) while searching for an image matching the description \"${description}\"`;
-        if (sessionId) {
-          const waitForImageDuration = Date.now() - startTime;
-          sandbox.send({
-            type: "trackInteraction",
-            interactionType: "waitForImage",
-            session: sessionId,
-            prompt: description,
-            input: { timeout },
-            timestamp: waitForImageTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-            duration: waitForImageDuration,
-            success: false,
-            error: errorMsg,
-          }).catch((err) => {
-            console.warn("Failed to track waitForImage interaction:", err.message);
-          });
-        }
+        const waitForImageDuration = Date.now() - startTime;
+        trackInteraction({
+          interactionType: "waitForImage",
+          prompt: description,
+          input: { timeout },
+          timestamp: waitForImageTimestamp,
+          duration: waitForImageDuration,
+          success: false,
+          error: errorMsg,
+        });
         
         throw new MatchError(errorMsg);
       }
@@ -1267,44 +1239,30 @@ const createCommands = (
         emitter.emit(events.log.narration, theme.dim(`"${text}" found!`), true);
         
         // Track interaction success (fire-and-forget)
-        const sessionId = sessionInstance?.get();
-        if (sessionId) {
-          const waitForTextDuration = Date.now() - startTime;
-          sandbox.send({
-            type: "trackInteraction",
-            interactionType: "waitForText",
-            session: sessionId,
-            prompt: text,
-            input: { timeout },
-            timestamp: waitForTextTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-            duration: waitForTextDuration,
-            success: true,
-          }).catch((err) => {
-            console.warn("Failed to track waitForText interaction:", err.message);
-          });
-        }
+        const waitForTextDuration = Date.now() - startTime;
+        trackInteraction({
+          interactionType: "waitForText",
+          prompt: text,
+          input: { timeout },
+          timestamp: waitForTextTimestamp,
+          duration: waitForTextDuration,
+          success: true,
+        });
         
         return;
       } else {
         // Track interaction failure (fire-and-forget)
-        const sessionId = sessionInstance?.get();
         const errorMsg = `Timed out (${niceSeconds(timeout)} seconds) while searching for "${text}"`;
-        if (sessionId) {
-          const waitForTextDuration = Date.now() - startTime;
-          sandbox.send({
-            type: "trackInteraction",
-            interactionType: "waitForText",
-            session: sessionId,
-            prompt: text,
-            input: { timeout },
-            timestamp: waitForTextTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-            duration: waitForTextDuration,
-            success: false,
-            error: errorMsg,
-          }).catch((err) => {
-            console.warn("Failed to track waitForText interaction:", err.message);
-          });
-        }
+        const waitForTextDuration = Date.now() - startTime;
+        trackInteraction({
+          interactionType: "waitForText",
+          prompt: text,
+          input: { timeout },
+          timestamp: waitForTextTimestamp,
+          duration: waitForTextDuration,
+          success: false,
+          error: errorMsg,
+        });
         
         throw new MatchError(errorMsg);
       }
@@ -1514,45 +1472,27 @@ const createCommands = (
         });
         
         // Track interaction success
-        const sessionId = sessionInstance?.get();
-        if (sessionId) {
-          try {
-            const rememberDuration = Date.now() - rememberStartTime;
-            await sandbox.send({
-              type: "trackInteraction",
-              interactionType: "extract",
-              session: sessionId,
-              prompt: description,
-              timestamp: rememberTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-              duration: rememberDuration,
-              success: true,
-            });
-          } catch (err) {
-            console.warn("Failed to track extract interaction:", err.message);
-          }
-        }
+        const rememberDuration = Date.now() - rememberStartTime;
+        trackInteraction({
+          interactionType: "extract",
+          prompt: description,
+          timestamp: rememberTimestamp,
+          duration: rememberDuration,
+          success: true,
+        });
         
         return result.data;
       } catch (error) {
         // Track interaction failure
-        const sessionId = sessionInstance?.get();
-        if (sessionId) {
-          try {
-            const rememberDuration = Date.now() - rememberStartTime;
-            await sandbox.send({
-              type: "trackInteraction",
-              interactionType: "extract",
-              session: sessionId,
-              prompt: description,
-              timestamp: rememberTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
-              duration: rememberDuration,
-              success: false,
-              error: error.message,
-            });
-          } catch (err) {
-            console.warn("Failed to track extract interaction:", err.message);
-          }
-        }
+        const rememberDuration = Date.now() - rememberStartTime;
+        trackInteraction({
+          interactionType: "extract",
+          prompt: description,
+          timestamp: rememberTimestamp,
+          duration: rememberDuration,
+          success: false,
+          error: error.message,
+        });
         throw error;
       }
     },

package/agent/lib/debugger-server.js

@@ -84,6 +84,13 @@ function createDebuggerServer(config = {}) {
         return;
       }
       const actualPort = address.port;
+      
+      // Don't let the debugger server prevent Node process from exiting
+      // This ensures tests can exit even if debugger cleanup fails
+      if (server.unref) {
+        server.unref();
+      }
+      
       resolve({ port: actualPort, server, wss });
     });
 
@@ -110,6 +117,9 @@ function broadcastEvent(event, data) {
 
 async function startDebugger(config = {}, emitter) {
   try {
+    // Register exit handler to ensure cleanup on process exit
+    registerExitHandler();
+    
     const { port } = await createDebuggerServer(config);
     const url = `http://localhost:${port}`;
 
@@ -190,6 +200,29 @@ function stopDebugger() {
   forceStopDebugger();
 }
 
+// Ensure debugger server is cleaned up on process exit
+// This prevents zombie processes when tests crash or cleanup fails
+let exitHandlerRegistered = false;
+function registerExitHandler() {
+  if (exitHandlerRegistered) return;
+  exitHandlerRegistered = true;
+  
+  process.on("exit", () => {
+    if (server || wss) {
+      // Synchronous cleanup - can't await in exit handler
+      if (wss) {
+        try { wss.close(); } catch (e) { /* ignore */ }
+        wss = null;
+      }
+      if (server) {
+        try { server.close(); } catch (e) { /* ignore */ }
+        server = null;
+      }
+      clients.clear();
+    }
+  });
+}
+
 module.exports = {
   startDebugger,
   stopDebugger,

package/agent/lib/sandbox.js

@@ -128,6 +128,10 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
             );
           }
         }, timeout);
+        // Don't let pending timeouts prevent Node process from exiting
+        if (timeoutId.unref) {
+          timeoutId.unref();
+        }
 
         // Track timeout so close() can clear it
         this.pendingTimeouts.set(requestId, timeoutId);
@@ -150,7 +154,7 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
 
         // Fire-and-forget message types: attach .catch() to prevent
         // unhandled promise rejections if nobody awaits the result
-        const fireAndForgetTypes = ["output", "trackInteraction"];
+        const fireAndForgetTypes = ["output"];
         if (fireAndForgetTypes.includes(message.type)) {
           p.catch(() => {});
         }
@@ -360,6 +364,10 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
           this.reconnecting = false;
         }
       }, delay);
+      // Don't let reconnect timer prevent Node process from exiting
+      if (this.reconnectTimer.unref) {
+        this.reconnectTimer.unref();
+      }
     }
 
     /**

package/agent/lib/sdk.js

@@ -346,6 +346,73 @@ const createSDK = (emitter, config, sessionInstance) => {
       }
     }
 
+    // ── S3 upload: replace large inline base64 images with S3 keys ──────
+    // If data.image is a large base64 string (>50KB), upload the raw PNG
+    // to S3 via a presigned URL and send only the imageKey instead.
+    // This reduces JSON body size from ~1.3MB to ~60 bytes.
+    const MIN_IMAGE_SIZE = 50_000; // 50KB base64 chars
+    if (
+      data &&
+      typeof data.image === "string" &&
+      data.image.length > MIN_IMAGE_SIZE
+    ) {
+      try {
+        const apiRoot = config["TD_API_ROOT"];
+        const uploadUrlEndpoint = [apiRoot, "api", version, "testdriver", "upload-url"].join("/");
+
+        // Step 1: Get presigned upload URL from API
+        const uploadRes = await axios(uploadUrlEndpoint, {
+          method: "post",
+          headers: {
+            "Content-Type": "application/json",
+            ...(token && { Authorization: `Bearer ${token}` }),
+          },
+          timeout: 15000,
+          data: {
+            session: sessionInstance.get(),
+            contentType: "image/png",
+          },
+        });
+
+        const { uploadUrl, imageKey } = uploadRes.data;
+
+        if (uploadUrl && imageKey) {
+          // Step 2: Upload raw PNG bytes to S3 via presigned PUT URL
+          const base64Data = data.image.replace(/^data:image\/\w+;base64,/, "");
+          const pngBuffer = Buffer.from(base64Data, "base64");
+
+          await axios(uploadUrl, {
+            method: "put",
+            headers: {
+              "Content-Type": "image/png",
+              "Content-Length": pngBuffer.length,
+            },
+            data: pngBuffer,
+            timeout: 30000,
+            maxBodyLength: Infinity,
+            maxContentLength: Infinity,
+          });
+
+          // Step 3: Replace image with imageKey in the request data
+          const savedKB = (data.image.length / 1024).toFixed(0);
+          delete data.image;
+          data.imageKey = imageKey;
+          emitter.emit(events.log?.debug || events.sdk.request, {
+            path,
+            message: `[sdk] uploaded screenshot to S3 (saved ${savedKB}KB inline), imageKey=${imageKey}`,
+          });
+        }
+      } catch (uploadErr) {
+        // Non-fatal: fall back to sending base64 inline
+        // This ensures old API servers without the upload-url endpoint still work
+        emitter.emit(events.log?.debug || events.sdk.request, {
+          path,
+          message: `[sdk] S3 upload failed, falling back to inline base64: ${uploadErr.message}`,
+        });
+      }
+    }
+    // ── End S3 upload ───────────────────────────────────────────────────
+
     emitter.emit(events.sdk.request, {
       path,
     });

package/examples/hover-image.test.mjs

@@ -13,11 +13,20 @@ import { getDefaults } from "./config.mjs";
  * @param {string} username - Username (default: 'standard_user')
  */
 async function performLogin(client, username = "standard_user") {
+  
+  console.log('Performing login with username:', username);
   await client.focusApplication("Google Chrome");
+
+  console.log('Extracting password from page');
   const password = await client.extract("the password");
+
+  console.log('Password extracted:', password ? '***' : 'not found');
+
   const usernameField = await client.find(
     "username input",
   );
+  
+  console.log('Clicking on username field and entering credentials');
   await usernameField.click();
   await client.type(username);
   await client.pressKeys(["tab"]);
@@ -35,6 +44,8 @@ describe("Hover Image Test", () => {
       url: 'http://testdriver-sandbox.vercel.app/login'
     });
 
+    console.log('starting login')
+
     // Perform login first
     await performLogin(testdriver);
 

package/lib/vitest/hooks.mjs

@@ -121,7 +121,6 @@ function bufferConsoleToClients(args, level) {
         line: message,
         level: level || "log",
         source: "console",
-        logFile: "console",
       });
     }
   }
@@ -217,47 +216,6 @@ function cleanupConsoleSpy(client) {
 const testDriverInstances = new WeakMap();
 const lifecycleHandlers = new WeakMap();
 
-/**
- * Known log file paths on the Windows test runner.
- * These are written by pyautogui-cli.py and related services.
- */
-const WINDOWS_RUNNER_LOG_PATHS = [
-  "C:\\Windows\\Temp\\pyautogui-cli.log",
-];
-
-/**
- * Fetch log files from the Windows test runner via exec() and save them locally.
- * This runs before disconnect so we can still communicate with the sandbox.
- *
- * @param {import('../../sdk.js').default} client - TestDriver SDK instance
- * @param {string} testName - Test file name (used for local directory naming)
- */
-async function fetchRunnerLogs(client, testName) {
-  if (!client.connected) return;
-  if (client.os !== "windows") return;
-
-  for (const remotePath of WINDOWS_RUNNER_LOG_PATHS) {
-    const localName = path.basename(remotePath);
-    try {
-      // Read the log file contents via PowerShell
-      const cmd = `if (Test-Path '${remotePath}') { Get-Content -Path '${remotePath}' -Raw } else { Write-Output '__FILE_NOT_FOUND__' }`;
-      const result = await Promise.race([
-        client.exec("pwsh", cmd, 10000, true),
-        new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 15000)),
-      ]);
-
-      if (result && typeof result === "string" && !result.includes("__FILE_NOT_FOUND__")) {
-        console.log(`\n[TestDriver] === Runner Log: ${localName} ===`);
-        console.log(result);
-        console.log(`[TestDriver] === End Runner Log ===\n`);
-      }
-    } catch (err) {
-      // Fire-and-forget — don't let log retrieval break cleanup
-      console.warn(`[TestDriver] Could not fetch runner log ${remotePath}: ${err.message}`);
-    }
-  }
-}
-
 /**
  * Upload buffered SDK + console logs directly to S3 via the existing Log system.
  * Extracts the replayId from the dashcam URL, calls POST /api/v1/logs to create
@@ -673,16 +631,6 @@ export function TestDriver(context, options = {}) {
         context.task.meta.dashcamUrl = null;
       }
 
-      // Fetch runner logs before disconnecting (Windows only)
-      // This grabs pyautogui-cli logs from the runner while we still have a connection
-      try {
-        const logTestName = testFile.replace(/[/\\]/g, "_").replace(/\.test\.m?js$/, "");
-        await fetchRunnerLogs(currentInstance, logTestName);
-      } catch (err) {
-        // Never let log retrieval block cleanup
-        console.warn("[TestDriver] Runner log fetch failed:", err.message);
-      }
-
       // Clean up console spies
       cleanupConsoleSpy(currentInstance);
 

package/package.json

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