testdriverai 7.3.33 → 7.3.35

package/.github/copilot-instructions.md

@@ -507,15 +507,64 @@ it("should incrementally build test", async (context) => {
 
 ```javascript
 const testdriver = TestDriver(context, {
-  newSandbox: true, // Create new sandbox (default: true)
-  preview: "browser", // "browser" | "ide" | "none" (default: "browser")
-  reconnect: false, // Reconnect to last sandbox (default: false)
-  keepAlive: 30000, // Keep sandbox alive after test (default: 30000ms / 30 seconds)
-  os: "linux", // 'linux' | 'windows' (default: 'linux')
-  resolution: "1366x768", // Sandbox resolution
-  cache: true, // Enable element caching (default: true)
-  cacheKey: "my-test", // Cache key for element finding
-  autoScreenshots: true, // Capture screenshots before/after each command (default: true)
+  // === Sandbox & Connection ===
+  newSandbox: true,          // Force creation of a new sandbox (default: true)
+  reconnect: false,          // Reconnect to last sandbox (default: false)
+  keepAlive: 30000,          // Keep sandbox alive after test in ms (default: 30000)
+  os: "linux",               // 'linux' | 'windows' (default: 'linux')
+  resolution: "1366x768",   // Sandbox resolution (e.g., '1920x1080')
+  ip: "203.0.113.42",       // Direct IP for self-hosted sandbox
+  sandboxAmi: "ami-1234",   // Custom AMI ID (AWS deployments)
+  sandboxInstance: "i3.metal", // EC2 instance type (AWS deployments)
+
+  // === Preview & Debugging ===
+  preview: "browser",        // "browser" | "ide" | "none" (default: "browser")
+  headless: false,           // @deprecated - use preview: "none" instead
+  debugOnFailure: false,     // Keep sandbox alive on test failure for debugging
+
+  // === Caching ===
+  cache: true,               // Enable element caching (default: true)
+  // Or use advanced caching config:
+  // cache: {
+  //   enabled: true,
+  //   thresholds: {
+  //     find: { screen: 0.05, element: 0.8 },
+  //     assert: 0.05
+  //   }
+  // },
+  cacheKey: "my-test",       // Cache key for element finding operations
+
+  // === Recording & Screenshots ===
+  dashcam: true,             // Enable/disable Dashcam video recording (default: true)
+  autoScreenshots: true,     // Capture screenshots before/after each command (default: true)
+
+  // === AI Configuration ===
+  ai: {                      // Global AI sampling configuration
+    temperature: 0,          // 0 = deterministic, higher = more creative
+    top: {
+      p: 0.9,               // Top-P nucleus sampling (0-1)
+      k: 40,                // Top-K sampling (1 = most likely, 0 = disabled)
+    },
+  },
+
+  // === Screen Change Detection ===
+  redraw: true,              // Enable redraw detection (default: true)
+  // Or use advanced redraw config:
+  // redraw: {
+  //   enabled: true,
+  //   thresholds: {
+  //     screen: 0.05,       // Pixel diff threshold (0-1), false to disable
+  //     network: false,     // Monitor network activity (default: false)
+  //   }
+  // },
+
+  // === Logging & Analytics ===
+  logging: true,             // Enable console logging output (default: true)
+  analytics: true,           // Enable analytics tracking (default: true)
+
+  // === Advanced ===
+  apiRoot: "https://...",    // API endpoint URL (for self-hosted deployments)
+  environment: {},           // Additional environment variables for the sandbox
 });
 ```
 

package/.github/workflows/windows-self-hosted.yaml

@@ -22,7 +22,7 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: testdriver-32
 
     steps:
       - name: Checkout repository
@@ -39,19 +39,8 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
-      - name: Debug Environment
-        run: |
-          echo "Checking environment variables..."
-          if [ -n "${{ secrets.TWOCAPTCHA_API_KEY }}" ]; then
-            echo "TWOCAPTCHA_API_KEY is set (length: ${#TWOCAPTCHA_API_KEY})"
-          else
-            echo "TWOCAPTCHA_API_KEY is NOT set"
-          fi
-        env:
-          TWOCAPTCHA_API_KEY: ${{ secrets.TWOCAPTCHA_API_KEY }}
-
-      - name: Run Windows tests with self-hosted instances
-        run: set -o pipefail && npx vitest run ${{ inputs.test_pattern }} 2>&1 | tee test-output.log
+      - name: Run Windows tests
+        run: set -o pipefail && npx vitest run ${{ inputs.test_pattern }} --maxWorkers 32 --sequence.concurrent 2>&1 | tee test-output.log
         env:
           TD_API_KEY: ${{ secrets.TD_API_KEY }}
           TWOCAPTCHA_API_KEY: ${{ secrets.TWOCAPTCHA_API_KEY }}

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [7.3.35](https://github.com/testdriverai/testdriverai/compare/v7.3.34...v7.3.35) (2026-02-24)
+
+
+
+## [7.3.34](https://github.com/testdriverai/testdriverai/compare/v7.3.33...v7.3.34) (2026-02-24)
+
+
+
 ## [7.3.33](https://github.com/testdriverai/testdriverai/compare/v7.3.32...v7.3.33) (2026-02-24)
 
 

package/agent/index.js

@@ -1635,105 +1635,6 @@ ${regression}
     this.emitter.emit(events.log.log, `${inputFile} (end)`);
   }
 
-  // Returns the path to the last sandbox file
-  getLastSandboxFilePath() {
-    const testdriverDir = path.join(process.cwd(), ".testdriver");
-    return path.join(testdriverDir, "last-sandbox");
-  }
-
-  // Returns full sandbox info from last-sandbox file (no timeout - let API validate)
-  getLastSandboxId() {
-    const lastSandboxFile = this.getLastSandboxFilePath();
-
-    if (fs.existsSync(lastSandboxFile)) {
-      try {
-        const fileContent = fs.readFileSync(lastSandboxFile, "utf-8").trim();
-
-        // Parse sandbox info (supports both old format and new format)
-        let sandboxInfo;
-        try {
-          sandboxInfo = JSON.parse(fileContent);
-        } catch {
-          return { sandboxId: fileContent || null };
-        }
-
-        return {
-          sandboxId: sandboxInfo.sandboxId || sandboxInfo.instanceId || null,
-          os: sandboxInfo.os || "linux",
-          ami: sandboxInfo.ami || null,
-          instanceType: sandboxInfo.instanceType || null,
-          timestamp: sandboxInfo.timestamp || null,
-        };
-      } catch {
-        // ignore errors
-      }
-    }
-    return null;
-  }
-
-  // Returns sandboxId to use if AMI/instance type match current requirements
-  getRecentSandboxId() {
-    const sandboxInfo = this.getLastSandboxId();
-
-    if (!sandboxInfo || !sandboxInfo.sandboxId) {
-      return null;
-    }
-
-    // Check if AMI and instance type match current requirements
-    const currentAmi = this.sandboxAmi || null;
-    const currentInstance = this.sandboxInstance || null;
-    const storedAmi = sandboxInfo.ami || null;
-    const storedInstance = sandboxInfo.instanceType || null;
-
-    if (currentAmi === storedAmi && currentInstance === storedInstance) {
-      return sandboxInfo.sandboxId;
-    } else {
-      this.emitter.emit(
-        events.log.log,
-        theme.dim(
-          "Recent sandbox found but AMI/instance type doesn't match current requirements",
-        ),
-      );
-      return null;
-    }
-  }
-
-  saveLastSandboxId(sandboxId, osType = "linux") {
-    const lastSandboxFile = this.getLastSandboxFilePath();
-    const testdriverDir = path.dirname(lastSandboxFile);
-
-    try {
-      // Ensure .testdriver directory exists
-      if (!fs.existsSync(testdriverDir)) {
-        fs.mkdirSync(testdriverDir, { recursive: true });
-      }
-
-      const sandboxInfo = {
-        sandboxId: sandboxId,
-        os: osType,
-        ami: this.sandboxAmi || null,
-        instanceType: this.sandboxInstance || null,
-        timestamp: new Date().toISOString(),
-      };
-      fs.writeFileSync(lastSandboxFile, JSON.stringify(sandboxInfo, null, 2), {
-        encoding: "utf-8",
-      });
-    } catch {
-      // ignore errors
-    }
-  }
-
-  clearRecentSandboxId() {
-    const lastSandboxFile = this.getLastSandboxFilePath();
-    try {
-      if (fs.existsSync(lastSandboxFile)) {
-        fs.unlinkSync(lastSandboxFile);
-      }
-    } catch {
-      // ignore errors
-    }
-  }
-
   async buildEnv(options = {}) {
     // If instance already exists, do not build environment again
     if (this.instance) {
@@ -1762,10 +1663,8 @@ ${regression}
 
     if (heal) this.healMode = heal;
 
-    // If createNew flag is set, clear the recent sandbox file to force creating a new sandbox
+    // If createNew flag is set, clear sandboxId to prevent reconnection attempts
     if (createNew) {
-      this.clearRecentSandboxId();
-      // Also clear this.sandboxId to prevent reconnection attempts
       this.sandboxId = null;
       if (!this.config.CI && !this.newSandbox) {
         this.emitter.emit(events.log.log, theme.dim("Creating a new sandbox"));
@@ -1780,8 +1679,6 @@ ${regression}
     // order is important!
     await this.connectToSandboxService();
 
-    const recentId = createNew ? null : this.getRecentSandboxId();
-
     // Set sandbox ID for reconnection (only if not creating new and recent ID exists)
     if (this.ip) {
       let instance = await this.sandbox.send({
@@ -1794,13 +1691,13 @@ ${regression}
       // 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 = {
+      this.sandbox.setConnectionParams({
         type: 'direct',
         ip: this.ip,
         sandboxId: instance?.instance?.instanceId || instance?.instance?.sandboxId || null,
         persist: true,
         keepAlive: this.keepAlive,
-      };
+      });
 
       // Mark instance socket as connected so console logs are forwarded
       this.sandbox.instanceSocketConnected = true;
@@ -1811,33 +1708,6 @@ ${regression}
       await this.runLifecycle("provision");
 
       return;
-    } else if (!createNew && recentId) {
-      // Only attempt to connect to existing sandbox if not in CI mode and not creating new
-      this.emitter.emit(
-        events.log.narration,
-        theme.dim(`using recent sandbox: ${recentId}`),
-      );
-      this.sandboxId = recentId;
-
-      try {
-        let instance = await this.connectToSandboxDirect(
-          this.sandboxId,
-          true, // always persist by default
-          this.keepAlive, // pass keepAlive TTL
-        );
-
-        this.instance = instance;
-
-        await this.renderSandbox(instance, headless);
-        return;
-      } catch (error) {
-        // If connection fails, fall through to creating a new sandbox
-        this.emitter.emit(
-          events.log.narration,
-          theme.dim(`failed to connect to recent sandbox, creating new one...`),
-        );
-        console.error("Failed to reconnect to sandbox:", error);
-      }
     } else if (!createNew && this.sandboxId && !this.config.CI) {
       // Only attempt to connect to existing sandbox if not in CI mode and not creating new
       // Attempt to connect to known instance
@@ -1892,9 +1762,6 @@ ${regression}
       this.sandboxId =
         newSandbox?.sandbox?.sandboxId || newSandbox?.sandbox?.instanceId;
 
-      // Use the configured sandbox OS type
-      this.saveLastSandboxId(this.sandboxId, this.sandboxOs);
-
       let instance = await this.connectToSandboxDirect(
         this.sandboxId,
         true, // always persist by default
@@ -2332,12 +2199,6 @@ Please check your network connection, TD_API_KEY, or the service status.`,
       }
 
       // Success - got a sandbox
-      if (response.sandbox && response.sandbox.sandboxId) {
-        this.saveLastSandboxId(response.sandbox.sandboxId, this.sandboxOs);
-      } else if (response.sandbox && response.sandbox.instanceId) {
-        this.saveLastSandboxId(response.sandbox.instanceId, this.sandboxOs);
-      }
-
       return response;
     }
   }

package/agent/lib/debugger-server.js

@@ -8,6 +8,8 @@ const logger = require("./logger");
 let server = null;
 let wss = null;
 let clients = new Set();
+let refCount = 0; // Number of active consumers (for concurrent test safety)
+let debuggerUrl = null; // Stored URL of running debugger
 
 function createDebuggerServer(config = {}) {
   const port = config.TD_DEBUGGER_PORT || 0; // 0 means find available port
@@ -76,7 +78,12 @@ function createDebuggerServer(config = {}) {
 
     // Start server on available port
     server.listen(port, "localhost", () => {
-      const actualPort = server.address().port;
+      const address = server.address();
+      if (!address) {
+        reject(new Error("Server started but address is not available"));
+        return;
+      }
+      const actualPort = address.port;
       resolve({ port: actualPort, server, wss });
     });
 
@@ -124,7 +131,43 @@ async function startDebugger(config = {}, emitter) {
   }
 }
 
-function stopDebugger() {
+/**
+ * Acquire a reference to the debugger server.
+ * Starts the server on first call; subsequent calls reuse the existing server.
+ * Each call increments a reference count — call releaseDebugger() when done.
+ *
+ * @param {Object} config - Debugger configuration
+ * @param {EventEmitter} emitter - Event emitter for broadcasting
+ * @returns {Promise<{port: number, url: string}>} Debugger connection info
+ */
+async function acquireDebugger(config = {}, emitter) {
+  refCount++;
+  if (server && debuggerUrl) {
+    // Server already running — reuse it
+    return { url: debuggerUrl };
+  }
+  // First consumer — start the server
+  const result = await startDebugger(config, emitter);
+  debuggerUrl = result.url;
+  return result;
+}
+
+/**
+ * Release a reference to the debugger server.
+ * Only actually stops the server when the last consumer releases.
+ */
+function releaseDebugger() {
+  if (refCount > 0) refCount--;
+  if (refCount > 0) return; // Other tests still using it
+  forceStopDebugger();
+}
+
+/**
+ * Forcefully stop the debugger server regardless of reference count.
+ * Used for process exit cleanup.
+ */
+function forceStopDebugger() {
+  refCount = 0;
   if (wss) {
     wss.close();
     wss = null;
@@ -136,12 +179,23 @@ function stopDebugger() {
   }
 
   clients.clear();
+  debuggerUrl = null;
+  module.exports.debuggerUrl = null;
+  module.exports.config = null;
   logger.log("Debugger server stopped");
 }
 
+// Keep stopDebugger as alias for forceStopDebugger for backward compatibility
+function stopDebugger() {
+  forceStopDebugger();
+}
+
 module.exports = {
   startDebugger,
   stopDebugger,
+  acquireDebugger,
+  releaseDebugger,
+  forceStopDebugger,
   broadcastEvent,
   createDebuggerServer,
   debuggerUrl: null,

package/agent/lib/sandbox.js

@@ -47,6 +47,7 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
       this.reconnecting = false; // Prevent duplicate reconnection attempts
       this.pendingTimeouts = new Map(); // Track per-message timeouts
       this.pendingRetryQueue = []; // Queue of requests to retry after reconnection
+      this._lastConnectParams = null; // Connection params for reconnection (per-instance, not shared)
     }
 
     /**
@@ -98,7 +99,7 @@ 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) {
+        if (this._lastConnectParams?.sandboxId && !message.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)) {
@@ -198,6 +199,22 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
       }
     }
 
+    /**
+     * Set connection params for reconnection logic and sandboxId injection.
+     * Use this instead of directly assigning this._lastConnectParams from
+     * external code. Keeps the shape consistent and avoids stale state
+     * leaking across concurrent test runs.
+     * @param {Object|null} params
+     * @param {string} [params.type] - 'direct' for IP-based connections
+     * @param {string} [params.ip] - IP address for direct connections
+     * @param {string} [params.sandboxId] - Sandbox/instance ID
+     * @param {boolean} [params.persist] - Whether to persist the sandbox
+     * @param {number|null} [params.keepAlive] - Keep-alive TTL in ms
+     */
+    setConnectionParams(params) {
+      this._lastConnectParams = params ? { ...params } : null;
+    }
+
     async connect(sandboxId, persist = false, keepAlive = null) {
       let reply = await this.send({
         type: "connect",
@@ -209,14 +226,14 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
       if (reply.success) {
         // Only store connection params after successful connection
         // This prevents malformed sandboxId from being attached to subsequent messages
-        this._lastConnectParams = { sandboxId, persist, keepAlive };
+        this.setConnectionParams({ sandboxId, persist, keepAlive });
         this.instanceSocketConnected = true;
         emitter.emit(events.sandbox.connected);
         // Return the full reply (includes url and sandbox)
         return reply;
       } else {
         // Clear any previous connection params on failure
-        this._lastConnectParams = null;
+        this.setConnectionParams(null);
         // Throw error to trigger fallback to creating new sandbox
         throw new Error(reply.errorMessage || "Failed to connect to sandbox");
       }
@@ -461,12 +478,17 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
 
           if (!this.ps[message.requestId]) {
             // This can happen during reconnection (ps was cleared) or after timeout
-            // (promise was deleted). Only log at debug level since it's expected.
+            // (promise was deleted). Expected during polling loops (e.g. Chrome
+            // debugger readiness checks) where short-timeout exec calls regularly
+            // expire before the sandbox responds.  Only log in debug/verbose mode.
             if (!this.reconnecting) {
-              console.warn(
-                "No pending promise found for requestId:",
-                message.requestId,
-              );
+              const debugMode = process.env.VERBOSE || process.env.DEBUG || process.env.TD_DEBUG;
+              if (debugMode) {
+                console.warn(
+                  "No pending promise found for requestId:",
+                  message.requestId,
+                );
+              }
             }
             return;
           }
@@ -528,6 +550,7 @@ const createSandbox = (emitter, analytics, sessionInstance) => {
       this.instanceSocketConnected = false;
       this.authenticated = false;
       this.instance = null;
+      this._lastConnectParams = null;
 
       // Silently clear pending promises and retry queue without rejecting
       // (rejecting causes unhandled promise rejections during cleanup)

package/docs/v7/client.mdx

@@ -25,7 +25,7 @@ const testdriver = new TestDriver(apiKey, options)
   Configuration options for the client
   
   <Expandable title="properties">
-    <ParamField path="os" type="string" default="windows">
+    <ParamField path="os" type="string" default="linux">
       Operating system for the sandbox: `'windows'` or `'linux'`
     </ParamField>
     
@@ -33,7 +33,7 @@ const testdriver = new TestDriver(apiKey, options)
       Screen resolution for the sandbox (e.g., `'1920x1080'`, `'1366x768'`)
     </ParamField>
     
-    <ParamField path="apiRoot" type="string" default="https://testdriver-api.onrender.com">
+    <ParamField path="apiRoot" type="string">
       API endpoint URL (typically only changed for self-hosted deployments)
     </ParamField>
     
@@ -49,6 +49,111 @@ const testdriver = new TestDriver(apiKey, options)
       Automatically capture screenshots before and after each command. Screenshots are saved to `.testdriver/screenshots/<test>/` with descriptive filenames that include the line number and action name. Format: `<seq>-<action>-<phase>-L<line>-<description>.png`
     </ParamField>
     
+    <ParamField path="newSandbox" type="boolean" default="true">
+      Force creation of a new sandbox instead of reusing an existing one
+    </ParamField>
+    
+    <ParamField path="reconnect" type="boolean" default="false">
+      Reconnect to the last used sandbox instead of creating a new one. When `true`, provision methods (`chrome`, `vscode`, `installer`, etc.) will be skipped since the application is already running. Throws error if no previous sandbox exists.
+    </ParamField>
+    
+    <ParamField path="keepAlive" type="number" default="60000">
+      Keep sandbox alive for the specified number of milliseconds after disconnect. Set to `0` to terminate immediately on disconnect. Useful for debugging or reconnecting to the same sandbox.
+    </ParamField>
+    
+    <ParamField path="preview" type="string" default="browser">
+      Preview mode for live test visualization:
+      - `"browser"` — Opens debugger in default browser (default)
+      - `"ide"` — Opens preview in IDE panel (VSCode, Cursor - requires TestDriver extension)
+      - `"none"` — Headless mode, no visual preview
+    </ParamField>
+    
+    <ParamField path="headless" type="boolean" default="false">
+      **Deprecated**: Use `preview: "none"` instead. Run in headless mode without opening the debugger.
+    </ParamField>
+    
+    <ParamField path="debugOnFailure" type="boolean" default="false">
+      Keep the sandbox alive when a test fails so you can reconnect and debug interactively. The sandbox ID is printed to the console.
+    </ParamField>
+    
+    <ParamField path="ip" type="string">
+      Direct IP address to connect to a running sandbox instance (for self-hosted deployments)
+    </ParamField>
+    
+    <ParamField path="sandboxAmi" type="string">
+      Custom AMI ID for the sandbox instance (AWS deployments, e.g., `'ami-1234'`)
+    </ParamField>
+    
+    <ParamField path="sandboxInstance" type="string">
+      EC2 instance type for the sandbox (AWS deployments, e.g., `'i3.metal'`)
+    </ParamField>
+    
+    <ParamField path="cache" type="boolean | object" default="true">
+      Enable or disable element caching, or provide advanced threshold configuration.
+      
+      <Expandable title="advanced config">
+        <ParamField path="enabled" type="boolean" default="true">
+          Enable or disable caching
+        </ParamField>
+        
+        <ParamField path="thresholds" type="object">
+          Fine-tune cache matching
+          
+          <Expandable title="properties">
+            <ParamField path="find" type="object">
+              Thresholds for `find()` operations
+              
+              <Expandable title="properties">
+                <ParamField path="screen" type="number" default="0.05">
+                  Pixel diff threshold for screen comparison (0-1). `0.05` = 5% diff allowed.
+                </ParamField>
+                
+                <ParamField path="element" type="number" default="0.8">
+                  OpenCV template match threshold for element matching (0-1). `0.8` = 80% correlation.
+                </ParamField>
+              </Expandable>
+            </ParamField>
+            
+            <ParamField path="assert" type="number" default="0.05">
+              Pixel diff threshold for `assert()` operations (0-1). `0.05` = 5% diff allowed.
+            </ParamField>
+          </Expandable>
+        </ParamField>
+      </Expandable>
+    </ParamField>
+    
+    <ParamField path="cacheKey" type="string">
+      Cache key for element finding operations. If provided, enables caching tied to this key.
+    </ParamField>
+    
+    <ParamField path="dashcam" type="boolean" default="true">
+      Enable or disable Dashcam video recording
+    </ParamField>
+    
+    <ParamField path="redraw" type="boolean | object" default="true">
+      Enable or disable screen-change (redraw) detection, or provide advanced configuration.
+      
+      <Expandable title="advanced config">
+        <ParamField path="enabled" type="boolean" default="true">
+          Enable or disable redraw detection
+        </ParamField>
+        
+        <ParamField path="thresholds" type="object">
+          Threshold configuration
+          
+          <Expandable title="properties">
+            <ParamField path="screen" type="number | false" default="0.05">
+              Pixel diff threshold (0-1). Set to `false` to disable screen redraw detection.
+            </ParamField>
+            
+            <ParamField path="network" type="boolean" default="false">
+              Enable or disable network activity monitoring
+            </ParamField>
+          </Expandable>
+        </ParamField>
+      </Expandable>
+    </ParamField>
+    
     <ParamField path="environment" type="object">
       Additional environment variables to pass to the sandbox
     </ParamField>

package/docs/v7/customizing-devices.mdx

@@ -10,7 +10,64 @@ Configure TestDriver behavior with options passed to the `TestDriver()` function
 
 ```javascript
 const testdriver = TestDriver(context, {
-  reconnect: false,
+  // === Sandbox & Connection ===
+  newSandbox: true,          // Force creation of a new sandbox (default: true)
+  reconnect: false,          // Reconnect to last sandbox (default: false)
+  keepAlive: 60000,          // Keep sandbox alive after disconnect in ms (default: 60000)
+  os: "linux",               // 'linux' | 'windows' (default: 'linux')
+  resolution: "1366x768",    // Sandbox resolution (e.g., '1920x1080')
+  ip: "203.0.113.42",        // Direct IP for self-hosted sandbox
+  sandboxAmi: "ami-1234",    // Custom AMI ID (AWS deployments)
+  sandboxInstance: "i3.metal", // EC2 instance type (AWS deployments)
+
+  // === Preview & Debugging ===
+  preview: "browser",        // "browser" | "ide" | "none" (default: "browser")
+  headless: false,           // @deprecated - use preview: "none" instead
+  debugOnFailure: false,     // Keep sandbox alive on test failure for debugging
+
+  // === Caching ===
+  cache: true,               // Enable element caching (default: true)
+  // Or use advanced caching config:
+  // cache: {
+  //   enabled: true,
+  //   thresholds: {
+  //     find: { screen: 0.05, element: 0.8 },
+  //     assert: 0.05
+  //   }
+  // },
+  cacheKey: "my-test",       // Cache key for element finding operations
+
+  // === Recording & Screenshots ===
+  dashcam: true,             // Enable/disable Dashcam video recording (default: true)
+  autoScreenshots: true,     // Capture screenshots before/after each command (default: true)
+
+  // === AI Configuration ===
+  ai: {                      // Global AI sampling configuration
+    temperature: 0,          // 0 = deterministic, higher = more creative
+    top: {
+      p: 0.9,               // Top-P nucleus sampling (0-1)
+      k: 40,                // Top-K sampling (1 = most likely, 0 = disabled)
+    },
+  },
+
+  // === Screen Change Detection ===
+  redraw: true,              // Enable redraw detection (default: true)
+  // Or use advanced redraw config:
+  // redraw: {
+  //   enabled: true,
+  //   thresholds: {
+  //     screen: 0.05,       // Pixel diff threshold (0-1), false to disable
+  //     network: false,     // Monitor network activity (default: false)
+  //   }
+  // },
+
+  // === Logging & Analytics ===
+  logging: true,             // Enable console logging output (default: true)
+  analytics: true,           // Enable analytics tracking (default: true)
+
+  // === Advanced ===
+  apiRoot: "https://...",    // API endpoint URL (for self-hosted deployments)
+  environment: {},           // Additional environment variables for the sandbox
 });
 ```
 
@@ -54,6 +111,16 @@ const testdriver = TestDriver(context, {
   The legacy `headless: true` option still works for backward compatibility and maps to `preview: "none"`.
 </Note>
 
+### Debug on Failure
+
+Keep the sandbox alive when a test fails so you can reconnect and debug interactively. The sandbox ID is printed to the console along with instructions for reconnecting via MCP.
+
+```javascript
+const testdriver = TestDriver(context, {
+  debugOnFailure: true,
+});
+```
+
 ### IP Target
 
 If self-hosting TestDriver, use `ip` to specify the device IP. See [Self-Hosting TestDriver](../self-hosting.md) for details.
@@ -105,11 +172,102 @@ steps:
   - run: TD_OS=${{ matrix.os }} vitest run
 ```
 
-## Keepalive
+### Dashcam Recording
+
+Dashcam video recording is enabled by default. Disable it to skip recording:
+
+```javascript
+const testdriver = TestDriver(context, {
+  dashcam: false,
+});
+```
+
+### Automatic Screenshots
+
+Screenshots are automatically captured before and after every command (click, type, find, assert, etc.) by default. Each screenshot filename includes the line number from your test file.
+
+Disable automatic screenshots:
+
+```javascript
+const testdriver = TestDriver(context, {
+  autoScreenshots: false,
+});
+```
+
+### Caching
+
+Element caching speeds up repeated `find()` and `assert()` calls. Enabled by default.
+
+```javascript
+// Disable caching
+const testdriver = TestDriver(context, {
+  cache: false,
+});
+
+// Advanced: custom thresholds
+const testdriver = TestDriver(context, {
+  cache: {
+    enabled: true,
+    thresholds: {
+      find: { screen: 0.05, element: 0.8 },
+      assert: 0.05,
+    },
+  },
+  cacheKey: "my-test",
+});
+```
 
-By default, sandboxes terminate immediately when the test finishes. Set this value to keep the sandbox alive for reconnection.
+### Redraw Detection
 
-The `keepAlive` param enables you to keep the sandbox running after the test completes for debugging or reconnection.  This will allow you to use the debugger to inspect the state of the device after the test has finished.
+Redraw detection waits for the screen to stabilize before taking actions. Enabled by default.
+
+```javascript
+// Disable redraw detection
+const testdriver = TestDriver(context, {
+  redraw: false,
+});
+
+// Advanced: custom thresholds with network monitoring
+const testdriver = TestDriver(context, {
+  redraw: {
+    enabled: true,
+    thresholds: {
+      screen: 0.05,
+      network: true,
+    },
+  },
+});
+```
+
+### AI Configuration
+
+Control how the AI model generates responses for `find()` verification and `assert()` calls:
+
+```javascript
+const testdriver = TestDriver(context, {
+  ai: {
+    temperature: 0,       // 0 = deterministic
+    top: { p: 0.9, k: 40 },
+  },
+});
+```
+
+### Environment Variables
+
+Pass additional environment variables to the sandbox:
+
+```javascript
+const testdriver = TestDriver(context, {
+  environment: {
+    MY_VAR: "value",
+    DEBUG: "true",
+  },
+});
+```
+
+## Keepalive
+
+By default, sandboxes stay alive for 60 seconds after disconnect. Customize this with `keepAlive`:
 
 ```javascript
 const testdriver = TestDriver(context, {
@@ -117,6 +275,14 @@ const testdriver = TestDriver(context, {
 });
 ```
 
+Set to `0` to terminate immediately:
+
+```javascript
+const testdriver = TestDriver(context, {
+  keepAlive: 0,  // Terminate sandbox immediately on disconnect
+});
+```
+
 ### Reconnecting to Existing Sandbox
 
 Speed up test development by reconnecting to an existing sandbox instead of starting fresh each time. This lets you iterate quickly on failing steps without re-running the entire test from the beginning.

package/examples/chrome-extension.test.mjs

@@ -65,31 +65,31 @@ describe("Chrome Extension Test", () => {
     expect(popupResult).toBeTruthy();
   });
 
-  it("should load Loom from Chrome Web Store by extensionId", async (context) => {
-    const testdriver = TestDriver(context, { ...getDefaults(context) });
-
-    // Launch Chrome with Loom loaded by its Chrome Web Store ID
-    // Loom ID: liecbddmkiiihnedobmlmillhodjkdmb
-    await testdriver.provision.chromeExtension({
-      extensionId: 'liecbddmkiiihnedobmlmillhodjkdmb'
-    });
-
-    // Navigate to testdriver.ai (extensions don't load on New Tab)
-    const addressBar = await testdriver.find("Chrome address bar");
-    await addressBar.click();
-    await testdriver.type("testdriver.ai");
-    await testdriver.pressKeys(["enter"]);
-
-    // Wait for page to load
-    const pageResult = await testdriver.assert("I can see testdriver.ai");
-    expect(pageResult).toBeTruthy();
-
-    // Click on the extensions button (puzzle piece icon) in Chrome toolbar
-    const extensionsButton = await testdriver.find("The puzzle-shaped icon in the Chrome toolbar.", {zoom: true});
-    await extensionsButton.click();
-
-    // Look for Loom in the extensions menu
-    const loomExtension = await testdriver.find("Loom extension in the extensions dropdown");
-    expect(loomExtension.found()).toBeTruthy();
-  });
+  // it("should load Loom from Chrome Web Store by extensionId", async (context) => {
+  //   const testdriver = TestDriver(context, { ...getDefaults(context) });
+
+  //   // Launch Chrome with Loom loaded by its Chrome Web Store ID
+  //   // Loom ID: liecbddmkiiihnedobmlmillhodjkdmb
+  //   await testdriver.provision.chromeExtension({
+  //     extensionId: 'liecbddmkiiihnedobmlmillhodjkdmb'
+  //   });
+
+  //   // Navigate to testdriver.ai (extensions don't load on New Tab)
+  //   const addressBar = await testdriver.find("Chrome address bar");
+  //   await addressBar.click();
+  //   await testdriver.type("testdriver.ai");
+  //   await testdriver.pressKeys(["enter"]);
+
+  //   // Wait for page to load
+  //   const pageResult = await testdriver.assert("I can see testdriver.ai");
+  //   expect(pageResult).toBeTruthy();
+
+  //   // Click on the extensions button (puzzle piece icon) in Chrome toolbar
+  //   const extensionsButton = await testdriver.find("The puzzle-shaped icon in the Chrome toolbar.", {zoom: true});
+  //   await extensionsButton.click();
+
+  //   // Look for Loom in the extensions menu
+  //   const loomExtension = await testdriver.find("Loom extension in the extensions dropdown");
+  //   expect(loomExtension.found()).toBeTruthy();
+  // });
 });

package/interfaces/vitest-plugin.mjs

@@ -1142,7 +1142,10 @@ class TestDriverReporter {
 
       const suiteName = test.suite?.name;
       const startTime = Date.now() - duration; // Calculate start time from duration
-      const retryCount = result.retryCount || 0;
+      // In Vitest v4, retryCount is on diagnostic(), not result()
+      // result() only returns { state, errors }, while diagnostic() has retryCount, duration, etc.
+      const diagnostic = test.diagnostic?.();
+      const retryCount = diagnostic?.retryCount || 0;
       const testRunDbId = process.env.TD_TEST_RUN_DB_ID;
       const consoleUrl = getConsoleUrl(pluginState.apiRoot);
       const hasRetries = retryCount > 0 && dashcamUrls.length > 1;

package/lib/sentry.js

@@ -16,7 +16,11 @@ const os = require("os");
 const { version } = require("../package.json");
 const logger = require("../agent/lib/logger");
 
-// Store the current session's trace context
+// Store trace contexts per session so concurrent tests don't overwrite each other.
+// Keys are sessionIds, values are { traceId, sessionId }.
+const _traceContexts = new Map();
+
+// For backward compatibility, track the most recently set session
 let currentTraceId = null;
 let currentSessionId = null;
 
@@ -177,7 +181,13 @@ function setSessionTraceContext(sessionId) {
   if (!isEnabled() || !sessionId) return;
 
   // Derive trace ID from session ID (same algorithm as API)
-  currentTraceId = crypto.createHash("md5").update(sessionId).digest("hex");
+  const traceId = crypto.createHash("md5").update(sessionId).digest("hex");
+
+  // Store per-session trace context for concurrent safety
+  _traceContexts.set(sessionId, { traceId, sessionId });
+
+  // Also update the module-level "latest" for backward compatibility
+  currentTraceId = traceId;
   currentSessionId = sessionId;
 
   // Set as global tag so all events include it
@@ -203,9 +213,26 @@ function setSessionTraceContext(sessionId) {
 /**
  * Clear the session trace context
  */
-function clearSessionTraceContext() {
-  currentTraceId = null;
-  currentSessionId = null;
+function clearSessionTraceContext(sessionId) {
+  if (sessionId) {
+    _traceContexts.delete(sessionId);
+    // If the cleared session was the "latest", pick another or null
+    if (currentSessionId === sessionId) {
+      if (_traceContexts.size > 0) {
+        const last = Array.from(_traceContexts.values()).pop();
+        currentTraceId = last.traceId;
+        currentSessionId = last.sessionId;
+      } else {
+        currentTraceId = null;
+        currentSessionId = null;
+      }
+    }
+  } else {
+    // Clear all (backward compatibility)
+    _traceContexts.clear();
+    currentTraceId = null;
+    currentSessionId = null;
+  }
 }
 
 /**

package/lib/vitest/hooks.mjs

@@ -131,7 +131,10 @@ function forwardToAllSandboxes(args) {
  * reporter output).
  */
 function installConsoleSpy() {
-  if (_consoleSpy.installed) return;
+  // Check both installed flag AND that spies are still valid.
+  // Guards against a race where cleanupConsoleSpy restores mocks (setting
+  // installed=false) while a new test is starting up concurrently.
+  if (_consoleSpy.installed && _consoleSpy.spies) return;
   _consoleSpy.installed = true;
 
   // Capture originals once — these are whatever console methods look like

package/lib/vitest/setup-aws.mjs

@@ -140,6 +140,14 @@ beforeEach(async (context) => {
     return;
   }
 
+  // If ip is provided via plugin options, skip spawning
+  const pluginIp = globalThis.__testdriverPlugin?.state?.testDriverOptions?.ip;
+  if (pluginIp) {
+    console.log(`[TestDriver] Using ip from plugin options: ${pluginIp}`);
+    context.ip = pluginIp;
+    return;
+  }
+
   if (!process.env.AWS_LAUNCH_TEMPLATE_ID || !process.env.AMI_ID) {
     throw new Error(
       "[TestDriver] TD_OS=windows requires AWS_LAUNCH_TEMPLATE_ID and AMI_ID environment variables",

package/lib/vitest/setup-self-hosted.mjs

@@ -81,6 +81,21 @@ beforeEach(async (context) => {
     return;
   }
 
+  // If TD_IP is already set, use it and skip spawning
+  if (process.env.TD_IP) {
+    console.log(`[TestDriver] Using existing instance at ${process.env.TD_IP}`);
+    context.ip = process.env.TD_IP;
+    return;
+  }
+
+  // If ip is provided via plugin options, skip spawning
+  const pluginIp = globalThis.__testdriverPlugin?.state?.testDriverOptions?.ip;
+  if (pluginIp) {
+    console.log(`[TestDriver] Using ip from plugin options: ${pluginIp}`);
+    context.ip = pluginIp;
+    return;
+  }
+
   // Verify AWS credentials are available
   if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_LAUNCH_TEMPLATE_ID || !process.env.AMI_ID) {
     throw new Error('[TestDriver] TD_OS=windows requires AWS credentials (AWS_ACCESS_KEY_ID, AWS_LAUNCH_TEMPLATE_ID, AMI_ID)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testdriverai",
-  "version": "7.3.33",
+  "version": "7.3.35",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",
@@ -23,7 +23,6 @@
     },
     "./vitest/setup": "./lib/vitest/setup.mjs",
     "./vitest/setup-aws": "./lib/vitest/setup-aws.mjs",
-    "./vitest/setup-disable-defender": "./lib/vitest/setup-disable-defender.mjs",
     "./vitest/hooks": {
       "types": "./lib/vitest/hooks.d.ts",
       "default": "./lib/vitest/hooks.mjs"

package/sdk.js

@@ -1399,6 +1399,10 @@ const TestDriverAgent = require("./agent/index.js");
 const { events } = require("./agent/events.js");
 const { createMarkdownLogger } = require("./interfaces/logger.js");
 
+// Track screenshot directories already cleaned in this process to avoid
+// concurrent tests in the same file from nuking each other's screenshots.
+const _cleanedScreenshotDirs = new Set();
+
 class TestDriverSDK {
   constructor(apiKey, options = {}) {
     // Support calling with just options: new TestDriver({ os: 'windows' })
@@ -1432,6 +1436,12 @@ class TestDriverSDK {
       ...options.environment,
     };
 
+    // Auto-detect CI environment (GitHub Actions, etc.) and pass through
+    // This ensures the API creates fresh sandboxes instead of reusing hot-pool instances
+    if (!environment.CI && process.env.CI) {
+      environment.CI = process.env.CI;
+    }
+
     // Create the underlying agent with minimal CLI args
     this.agent = new TestDriverAgent(environment, {
       command: "sdk",
@@ -1710,22 +1720,29 @@ class TestDriverSDK {
    * @param {number} [timeoutMs=60000] - Maximum time to wait in ms
    * @returns {Promise<void>}
    */
-  async _waitForChromeDebuggerReady(timeoutMs = 300000) {
+  async _waitForChromeDebuggerReady(timeoutMs = 60000) {
     const shell = this.os === "windows" ? "pwsh" : "sh";
     const portCheckCmd = this.os === "windows"
       ? `$tcp = New-Object System.Net.Sockets.TcpClient; $tcp.Connect('127.0.0.1', 9222); $tcp.Close(); echo 'open'`
       : `curl -s -o /dev/null --connect-timeout 2 http://localhost:9222 2>/dev/null && echo 'open' || echo 'closed'`;
-    const pageCheckCmd = this.os === "windows"
-      ? `(Invoke-RestMethod -Uri 'http://localhost:9222/json' -TimeoutSec 2) | Where-Object { $_.type -eq 'page' } | Select-Object -First 1 | ConvertTo-Json`
-      : `curl -s http://localhost:9222/json 2>/dev/null | grep '"type": "page"'`;
 
     const deadline = Date.now() + timeoutMs;
 
+    // Use commands.exec directly to bypass auto-screenshots wrapper.
+    // The polling loop fires many rapid exec calls with short timeouts;
+    // going through the wrapper adds 2-3 extra sandbox messages
+    // (screenshot before/after/error) per iteration, overwhelming the
+    // WebSocket and generating cascading "No pending promise" warnings
+    // when timed-out responses arrive after the promise has been cleaned up.
+    const execDirect = this.commands?.exec
+      ? (...args) => this.commands.exec(...args)
+      : (...args) => this.exec(...args); // fallback if commands not ready
+
     // Wait for port 9222 to be listening
     let portReady = false;
     while (Date.now() < deadline) {
       try {
-        const result = await this.exec(shell, portCheckCmd, 5000, true);
+        const result = await execDirect(shell, portCheckCmd, 10000, true);
         if (result && result.includes("open")) {
           portReady = true;
           break;
@@ -1733,7 +1750,7 @@ class TestDriverSDK {
       } catch (_) {
         // Port not ready yet
       }
-      await new Promise((r) => setTimeout(r, 200));
+      await new Promise((r) => setTimeout(r, 2000));
     }
     if (!portReady) {
       throw new Error(
@@ -1741,25 +1758,6 @@ class TestDriverSDK {
       );
     }
 
-    // Wait for a page target to appear via CDP
-    let pageReady = false;
-    while (Date.now() < deadline) {
-      try {
-        const result = await this.exec(shell, pageCheckCmd, 5000, true);
-        if (result && result.trim().length > 0) {
-          pageReady = true;
-          break;
-        }
-      } catch (_) {
-        // No page target yet
-      }
-      await new Promise((r) => setTimeout(r, 500));
-    }
-    if (!pageReady) {
-      throw new Error(
-        `Chrome page target did not become available within ${timeoutMs}ms`,
-      );
-    }
   }
 
   _createProvisionAPI() {
@@ -2706,7 +2704,9 @@ CAPTCHA_SOLVER_EOF`,
       );
     }
 
-    // Clean up screenshots folder for this test file before running
+    // Clean up screenshots folder for this test file before running.
+    // Only clean once per directory per process to avoid concurrent tests
+    // in the same file (--sequence.concurrent) from nuking each other's screenshots.
     if (this.testFile) {
       const testFileName = path.basename(
         this.testFile,
@@ -2718,8 +2718,11 @@ CAPTCHA_SOLVER_EOF`,
         "screenshots",
         testFileName,
       );
-      if (fs.existsSync(screenshotsDir)) {
-        fs.rmSync(screenshotsDir, { recursive: true, force: true });
+      if (!_cleanedScreenshotDirs.has(screenshotsDir)) {
+        _cleanedScreenshotDirs.add(screenshotsDir);
+        if (fs.existsSync(screenshotsDir)) {
+          fs.rmSync(screenshotsDir, { recursive: true, force: true });
+        }
       }
     }
 
@@ -2746,33 +2749,6 @@ CAPTCHA_SOLVER_EOF`,
           : this.newSandbox,
     };
 
-    // Handle reconnect option - use last sandbox file
-    // Check both connectOptions and constructor options
-    const shouldReconnect =
-      connectOptions.reconnect !== undefined
-        ? connectOptions.reconnect
-        : this.reconnect;
-
-    // Skip reconnect if IP is supplied - directly connect to the provided IP
-    const hasIp = Boolean(connectOptions.ip || this.ip);
-
-    if (shouldReconnect && !hasIp) {
-      const lastSandbox = this.agent.getLastSandboxId();
-      if (!lastSandbox || !lastSandbox.sandboxId) {
-        throw new Error(
-          "Cannot reconnect: No previous sandbox found. Run a test first to create a sandbox, or remove the reconnect option.",
-        );
-      }
-      this.agent.sandboxId = lastSandbox.sandboxId;
-      buildEnvOptions.new = false;
-
-      // Use OS from last sandbox if not explicitly specified
-      if (!connectOptions.os && lastSandbox.os) {
-        this.agent.sandboxOs = lastSandbox.os;
-        this.os = lastSandbox.os;
-      }
-    }
-
     // Set agent properties for buildEnv to use
     if (connectOptions.sandboxId) {
       this.agent.sandboxId = connectOptions.sandboxId;
@@ -2883,10 +2859,11 @@ CAPTCHA_SOLVER_EOF`,
       }
     }
 
-    // Stop the debugger server (HTTP + WebSocket server) to release the port
+    // Release our reference to the shared debugger server.
+    // The server only actually stops when the last concurrent test disconnects.
     try {
-      const { stopDebugger } = require("./agent/lib/debugger-server.js");
-      stopDebugger();
+      const { releaseDebugger } = require("./agent/lib/debugger-server.js");
+      releaseDebugger();
     } catch (err) {
       // Ignore if debugger wasn't started
     }
@@ -2916,14 +2893,6 @@ CAPTCHA_SOLVER_EOF`,
     return this.session?.get() || null;
   }
 
-  /**
-   * Get the last sandbox info from the stored file
-   * @returns {Object|null} Last sandbox info including sandboxId, os, ami, instanceType, timestamp, or null if not found
-   */
-  getLastSandboxId() {
-    return this.agent.getLastSandboxId();
-  }
-
   // ====================================
   // Element Finding API
   // ====================================
@@ -3924,16 +3893,13 @@ CAPTCHA_SOLVER_EOF`,
    * @private
    */
   async _initializeDebugger() {
-    // Import createDebuggerProcess at the module level if not already done
-    const { createDebuggerProcess } = require("./agent/lib/debugger.js");
+    // Use reference-counted debugger server so concurrent tests share one
+    // server and it only shuts down when the last test disconnects.
+    const { acquireDebugger } = require("./agent/lib/debugger-server.js");
 
-    // Only initialize once
     if (!this.agent.debuggerUrl) {
-      const debuggerProcess = await createDebuggerProcess(
-        this.config,
-        this.emitter,
-      );
-      this.agent.debuggerUrl = debuggerProcess.url || null;
+      const result = await acquireDebugger(this.config, this.emitter);
+      this.agent.debuggerUrl = result.url || null;
     }
   }
 

package/vitest.config.mjs

@@ -5,17 +5,17 @@ import { defineConfig } from "vitest/config";
 // Note: dotenv is loaded automatically by the TestDriver SDK
 const setupFiles = [
   "testdriverai/vitest/setup",
-  "testdriverai/vitest/setup-aws",
-  'testdriverai/vitest/setup-disable-defender'
+  "testdriverai/vitest/setup-aws"
 ];
 
 export default defineConfig({
   test: {
-    retry: 1,
+    retry: 0,
     testTimeout: 900000,
     hookTimeout: 900000,
     disableConsoleIntercept: true,
     maxConcurrency: 100,
+    maxWorkers: 16,
     reporters: [
       "default",
       TestDriver(),

package/lib/vitest/setup-disable-defender.mjs

@@ -1,52 +0,0 @@
-/**
- * Post-spawn hook to disable Windows Defender
- * 
- * Usage in vitest.config.mjs:
- * ```js
- * setupFiles: [
- *   'testdriverai/vitest/setup',
- *   'testdriverai/vitest/setup-aws',
- *   'testdriverai/vitest/setup-disable-defender'
- * ]
- * ```
- */
-
-import { execSync } from 'child_process';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { beforeEach } from 'vitest';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-beforeEach(async (context) => {
-  // Only run if we have an instance IP (self-hosted mode)
-  if (!context.ip) return;
-
-  // Get instance ID from global state set by setup-aws
-  const instanceInfo = globalThis.__testdriverAWS?.instances?.get(context.task.id);
-  if (!instanceInfo?.instanceId) {
-    console.warn('[TestDriver] No instance ID found, skipping Defender disable');
-    return;
-  }
-
-  const { instanceId, awsRegion } = instanceInfo;
-  const scriptPath = join(__dirname, '../../setup/aws/disable-defender.sh');
-
-  console.log(`[TestDriver] Disabling Windows Defender on ${instanceId}...`);
-
-  try {
-    execSync(`bash ${scriptPath}`, {
-      encoding: 'utf-8',
-      env: {
-        ...process.env,
-        AWS_REGION: awsRegion,
-        INSTANCE_ID: instanceId,
-      },
-      stdio: 'inherit',
-    });
-  } catch (error) {
-    console.warn('[TestDriver] Failed to disable Defender:', error.message);
-    // Don't throw - this is optional optimization
-  }
-});