testdriverai 7.1.0 → 7.1.1

package/{src → lib}/core/Dashcam.js

@@ -17,6 +17,7 @@ class Dashcam {
    * @param {string} [options.apiKey] - Dashcam API key
    * @param {boolean} [options.autoStart=false] - Auto-start recording
    * @param {Array} [options.logs=[]] - Log configurations to add
+   * @param {string} [options.title] - Recording title (defaults to generated title)
    */
   constructor(client, options = {}) {
     if (!client) {
@@ -31,6 +32,30 @@ class Dashcam {
     this.recording = false;
     this._authenticated = false;
     this.startTime = null; // Track when dashcam recording started
+    this.title = options.title || this._generateDefaultTitle();
+  }
+
+  /**
+   * Generate a default title for the recording
+   * Uses test context if available, otherwise falls back to timestamp
+   * @private
+   */
+  _generateDefaultTitle() {
+    // Check for Vitest context
+    if (this.client.__vitestContext) {
+      const task = this.client.__vitestContext;
+      const testName = task.name || 'Test';
+      const fileName = task.file?.name || task.file?.filepath;
+      if (fileName) {
+        const baseName = fileName.split('/').pop().replace(/\.(test|spec)\.(js|mjs|ts|tsx)$/, '');
+        return `${baseName} - ${testName}`;
+      }
+      return testName;
+    }
+    
+    // Fallback to timestamp
+    const now = new Date();
+    return `Recording ${now.toISOString().replace(/T/, ' ').replace(/\..+/, '')}`;
   }
 
   /**
@@ -46,7 +71,7 @@ class Dashcam {
    * @private
    */
   _getApiRoot() {
-    return this.client.config?.TD_API_ROOT || 'http://localhost:1337';
+    return this.client.config?.TD_API_ROOT || 'https://testdriver-api.onrender.com';
   }
 
   /**
@@ -291,10 +316,11 @@ class Dashcam {
       
       // Start dashcam record and redirect output with TD_API_ROOT
       const outputFile = 'C:\\Users\\testdriver\\.dashcam-cli\\dashcam-start.log';
+      const titleArg = this.title ? ` --title="${this.title.replace(/"/g, '\"')}"` : '';
       const startScript = `
         try {
           $env:TD_API_ROOT="${apiRoot}"
-          $process = Start-Process "cmd.exe" -ArgumentList "/c", "${dashcamPath} record > ${outputFile} 2>&1" -PassThru
+          $process = Start-Process "cmd.exe" -ArgumentList "/c", "${dashcamPath} record${titleArg} > ${outputFile} 2>&1" -PassThru
           Write-Output "Process started with PID: $($process.Id)"
           Start-Sleep -Seconds 2
           if ($process.HasExited) {
@@ -327,7 +353,8 @@ class Dashcam {
     } else {
       // Linux/Mac with TD_API_ROOT
       this._log('info', 'Starting dashcam recording on Linux/Mac...');
-      await this.client.exec(shell, `TD_API_ROOT="${apiRoot}" dashcam record >/dev/null 2>&1 &`);
+      const titleArg = this.title ? ` --title="${this.title.replace(/"/g, '\"')}"` : '';
+      await this.client.exec(shell, `TD_API_ROOT="${apiRoot}" dashcam record${titleArg} >/dev/null 2>&1 &`);
       this._log('info', 'Dashcam recording started');
     }
 
@@ -337,7 +364,7 @@ class Dashcam {
     // Update the session with dashcam start time for interaction timestamp synchronization
     if (this.client && this.client.agent && this.client.agent.session) {
       try {
-        const apiRoot = this.apiRoot || process.env.TD_API_ROOT || 'https://app.testdriver.ai';
+        const apiRoot = this.apiRoot || process.env.TD_API_ROOT || 'https://console.testdriver.ai';
         const response = await fetch(`${apiRoot}/api/v7.0.0/testdriver/session/${this.client.agent.session}/update-dashcam-time`, {
           method: 'POST',
           headers: {
@@ -358,6 +385,16 @@ class Dashcam {
     }
   }
 
+  /**
+   * Set the recording title
+   * This can be called before start() to customize the title
+   * @param {string} title - Custom recording title
+   */
+  setTitle(title) {
+    this.title = title;
+    this._log('info', `Set dashcam recording title: ${title}`);
+  }
+
   /**
    * Stop dashcam recording and retrieve replay URL
    * @returns {Promise<string|null>} Replay URL if available

package/{src → lib}/vitest/hooks.mjs

@@ -18,102 +18,106 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { vi } from 'vitest';
 import TestDriverSDK from '../../sdk.js';
 
 /**
- * Intercept console logs and write to a log file on the remote machine
- * This allows test logs to appear in Dashcam recordings
+ * Set up console spies using Vitest's vi.spyOn to intercept console logs
+ * and forward them to the sandbox for Dashcam visibility.
+ * This is test-isolated and doesn't cause conflicts with concurrent tests.
  * @param {TestDriver} client - TestDriver client instance
  * @param {string} taskId - Unique task identifier for this test
  */
-function setupConsoleInterceptor(client, taskId) {
-  // Store original console methods
-  const originalConsole = {
-    log: console.log,
-    error: console.error,
-    warn: console.warn,
-    info: console.info,
-  };
+function setupConsoleSpy(client, taskId) {
 
-  // Determine log file path based on OS
-  const logPath = client.os === "windows" 
-    ? "C:\\Users\\testdriver\\Documents\\testdriver.log"
-    : "/tmp/testdriver.log";
+  // Debug logging for console spy setup
+  const debugConsoleSpy = process.env.TD_DEBUG_CONSOLE_SPY === 'true';
+  if (debugConsoleSpy) {
+    process.stdout.write(`[DEBUG setupConsoleSpy] taskId: ${taskId}\n`);
+    process.stdout.write(`[DEBUG setupConsoleSpy] client.sandbox exists: ${!!client.sandbox}\n`);
+    process.stdout.write(`[DEBUG setupConsoleSpy] client.sandbox?.instanceSocketConnected: ${client.sandbox?.instanceSocketConnected}\n`);
+    process.stdout.write(`[DEBUG setupConsoleSpy] client.sandbox?.send: ${typeof client.sandbox?.send}\n`);
+  }
 
-  // Store log path on client for later use
-  client._testLogPath = logPath;
+  // Track forwarding stats
+  let forwardedCount = 0;
+  let skippedCount = 0;
 
-  // Track if we're currently writing to avoid infinite loops
-  let isWriting = false;
+  // Helper to forward logs to sandbox
+  const forwardToSandbox = (args) => {
+    const message = args
+      .map((arg) =>
+        typeof arg === "object"
+          ? JSON.stringify(arg, null, 2)
+          : String(arg),
+      )
+      .join(" ");
 
-  // Create wrapper that writes to log file
-  const createInterceptor = (level, originalMethod) => {
-    return function (...args) {
-      // Call original console method first
-      originalMethod.apply(console, args);
+    // Send to sandbox for immediate visibility in dashcam
+    if (client.sandbox && client.sandbox.instanceSocketConnected) {
+      try {
+        client.sandbox.send({
+          type: "output",
+          output: Buffer.from(message, "utf8").toString("base64"),
+        });
+        forwardedCount++;
+        if (debugConsoleSpy && forwardedCount <= 3) {
+          process.stdout.write(`[DEBUG forwardToSandbox] Forwarded message #${forwardedCount}: "${message.substring(0, 50)}..."\n`);
+        }
+      } catch (err) {
+        if (debugConsoleSpy) {
+          process.stdout.write(`[DEBUG forwardToSandbox] Error sending: ${err.message}\n`);
+        }
+      }
+    } else {
+      skippedCount++;
+      if (debugConsoleSpy && skippedCount <= 3) {
+        process.stdout.write(`[DEBUG forwardToSandbox] SKIPPED (sandbox not connected): "${message.substring(0, 50)}..."\n`);
+      }
+    }
+  };
 
-      // Skip if already writing to avoid infinite loops
-      if (isWriting) return;
+  // Create spies for each console method
+  const logSpy = vi.spyOn(console, 'log').mockImplementation((...args) => {
+    // Call through to original
+    logSpy.mock.calls; // Track calls
+    process.stdout.write(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' ') + '\n');
+    forwardToSandbox(args);
+  });
 
-      // Format the log message
-      const message = args
-        .map((arg) =>
-          typeof arg === "object"
-            ? JSON.stringify(arg, null, 2)
-            : String(arg),
-        )
-        .join(" ");
+  const errorSpy = vi.spyOn(console, 'error').mockImplementation((...args) => {
+    process.stderr.write(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' ') + '\n');
+    forwardToSandbox(args);
+  });
 
-      // Also send to sandbox for immediate visibility
-      if (client.sandbox && client.sandbox.instanceSocketConnected) {
-  
-          client.sandbox.send({
-            type: "output",
-            output: Buffer.from(message, "utf8").toString("base64"),
-          });
-      }
-    };
-  };
+  const warnSpy = vi.spyOn(console, 'warn').mockImplementation((...args) => {
+    process.stderr.write(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' ') + '\n');
+    forwardToSandbox(args);
+  });
 
-  // Replace console methods with interceptors
-  console.log = createInterceptor("log", originalConsole.log);
-  console.error = createInterceptor("error", originalConsole.error);
-  console.warn = createInterceptor("warn", originalConsole.warn);
-  console.info = createInterceptor("info", originalConsole.info);
+  const infoSpy = vi.spyOn(console, 'info').mockImplementation((...args) => {
+    process.stdout.write(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' ') + '\n');
+    forwardToSandbox(args);
+  });
 
-  // Store original methods and taskId on client for cleanup
-  client._consoleInterceptor = {
-    taskId,
-    original: originalConsole,
-  };
+  // Store spies on client for cleanup
+  client._consoleSpies = { logSpy, errorSpy, warnSpy, infoSpy };
 
-  // Use original console for this message
-  originalConsole.log(
-    `[useTestDriver] Console interceptor enabled for task: ${taskId}`,
-  );
+  console.log(`[testdriver] Console spy set up for task: ${taskId}`);
 }
 
 /**
- * Remove console interceptor and restore original console methods
+ * Clean up console spies and restore original console methods
  * @param {TestDriver} client - TestDriver client instance
  */
-function removeConsoleInterceptor(client) {
-  if (client._consoleInterceptor) {
-    const { original, taskId } = client._consoleInterceptor;
-
-    // Restore original console methods
-    console.log = original.log;
-    console.error = original.error;
-    console.warn = original.warn;
-    console.info = original.info;
-
-    // Use original console for cleanup message
-    original.log(
-      `[useTestDriver] Console interceptor removed for task: ${taskId}`,
-    );
-
-    // Clean up reference
-    delete client._consoleInterceptor;
+function cleanupConsoleSpy(client) {
+  if (client._consoleSpies) {
+    const { logSpy, errorSpy, warnSpy, infoSpy } = client._consoleSpies;
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    warnSpy.mockRestore();
+    infoSpy.mockRestore();
+    delete client._consoleSpies;
   }
 }
 
@@ -176,16 +180,27 @@ export function TestDriver(context, options = {}) {
   
   // Auto-connect if enabled (default: true)
   const autoConnect = config.autoConnect !== undefined ? config.autoConnect : true;
+  const debugConsoleSpy = process.env.TD_DEBUG_CONSOLE_SPY === 'true';
+  
   if (autoConnect) {
     testdriver.__connectionPromise = (async () => {
-      try {
         console.log('[testdriver] Connecting to sandbox...');
+        if (debugConsoleSpy) {
+          console.log('[DEBUG] Before auth - sandbox.instanceSocketConnected:', testdriver.sandbox?.instanceSocketConnected);
+        }
+        
         await testdriver.auth();
         await testdriver.connect();
+        
         console.log('[testdriver] ✅ Connected to sandbox');
         
-        // Set up console interceptor after connection
-        setupConsoleInterceptor(testdriver, context.task.id);
+        if (debugConsoleSpy) {
+          console.log('[DEBUG] After connect - sandbox.instanceSocketConnected:', testdriver.sandbox?.instanceSocketConnected);
+          console.log('[DEBUG] After connect - sandbox.send:', typeof testdriver.sandbox?.send);
+        }
+        
+        // Set up console spy using vi.spyOn (test-isolated)
+        setupConsoleSpy(testdriver, context.task.id);
         
         // Create the log file on the remote machine
         const shell = testdriver.os === "windows" ? "pwsh" : "sh";
@@ -202,23 +217,9 @@ export function TestDriver(context, options = {}) {
         
         // Add automatic log tracking when dashcam starts
         // Store original start method
-        const originalDashcamStart = testdriver.dashcam.start.bind(testdriver.dashcam);
-        testdriver.dashcam.start = async function() {
-          // Call original start (which handles auth)
-          await originalDashcamStart();
-          
-          // Add log file tracking after dashcam starts
-          try {
-            await testdriver.dashcam.addFileLog(logPath, "TestDriver Log");
-            console.log('[testdriver] ✅ Added log file to dashcam tracking');
-          } catch (error) {
-            console.warn('[testdriver] ⚠️  Failed to add log tracking:', error.message);
-          }
-        };
-      } catch (error) {
-        console.error('[testdriver] Error during setup:', error);
-        throw error;
-      }
+
+        await testdriver.dashcam.addFileLog(logPath, "TestDriver Log");
+
     })();
   }
   
@@ -227,10 +228,18 @@ export function TestDriver(context, options = {}) {
     const cleanup = async () => {
       console.log('[testdriver] Cleaning up TestDriver client...');
       try {
-        // Stop dashcam if it was started
+        // Stop dashcam if it was started - with timeout to prevent hanging
         if (testdriver._dashcam && testdriver._dashcam.recording) {
           try {
-            const dashcamUrl = await testdriver.dashcam.stop();
+            // Add a timeout wrapper to prevent dashcam.stop from hanging indefinitely
+            const stopWithTimeout = Promise.race([
+              testdriver.dashcam.stop(),
+              new Promise((_, reject) => 
+                setTimeout(() => reject(new Error('Dashcam stop timed out after 30s')), 30000)
+              )
+            ]);
+            
+            const dashcamUrl = await stopWithTimeout;
             console.log('🎥 Dashcam URL:', dashcamUrl);
             
             // Write dashcam URL to file for the reporter (cross-process communication)
@@ -272,17 +281,26 @@ export function TestDriver(context, options = {}) {
             if (error.name === 'NotFoundError' || error.responseData?.error === 'NotFoundError') {
               console.log('   ℹ️  Sandbox session already terminated - dashcam stop skipped');
             }
+            // Mark as not recording to prevent retries
+            if (testdriver._dashcam) {
+              testdriver._dashcam.recording = false;
+            }
           }
         }
         
-        // Remove console interceptor before disconnecting
-        removeConsoleInterceptor(testdriver);
+        // Clean up console spies
+        cleanupConsoleSpy(testdriver);
         
         // Wait for connection to finish if it was initiated
         if (testdriver.__connectionPromise) {
           await testdriver.__connectionPromise.catch(() => {}); // Ignore connection errors during cleanup
         }
-        await testdriver.disconnect();
+        
+        // Disconnect with timeout
+        await Promise.race([
+          testdriver.disconnect(),
+          new Promise((resolve) => setTimeout(resolve, 5000)) // 5s timeout for disconnect
+        ]);
         console.log('✅ Client disconnected');
       } catch (error) {
         console.error('Error disconnecting client:', error);

package/lib/vitest/setup.mjs

@@ -0,0 +1,44 @@
+/**
+ * Vitest Setup File for TestDriver
+ * 
+ * This file is run by Vitest before each test file to set up
+ * the TestDriver plugin state and global helpers.
+ * 
+ * Usage in vitest.config.mjs:
+ * ```js
+ * export default defineConfig({
+ *   test: {
+ *     setupFiles: ['testdriverai/vitest/setup'],
+ *   },
+ * });
+ * ```
+ */
+
+import {
+  clearDashcamUrls,
+  clearSuiteTestRun,
+  getDashcamUrl,
+  getPluginState,
+  getSuiteTestRun,
+  pluginState,
+  registerDashcamUrl,
+  setSuiteTestRun,
+} from '../../interfaces/vitest-plugin.mjs';
+
+// Set up global TestDriver plugin interface
+// This allows tests and the SDK to communicate with the reporter
+globalThis.__testdriverPlugin = {
+  state: pluginState,
+  registerDashcamUrl,
+  getDashcamUrl,
+  clearDashcamUrls,
+  getPluginState,
+  getSuiteTestRun,
+  setSuiteTestRun,
+  clearSuiteTestRun,
+};
+
+// Log that setup is complete (only in debug mode)
+if (process.env.TD_LOG_LEVEL?.toLowerCase() === 'debug') {
+  console.log('[TestDriver] Setup file initialized, global plugin interface available');
+}

package/package.json

@@ -1,18 +1,16 @@
 {
   "name": "testdriverai",
-  "version": "7.1.0",
+  "version": "7.1.1",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "exports": {
     ".": "./sdk.js",
-    "./core": "./src/core/index.js",
-    "./vitest": "./src/vitest/index.mjs",
-    "./vitest/hooks": "./src/vitest/hooks.mjs",
-    "./vitest/extended": "./src/vitest/extended.mjs",
-    "./vitest/lifecycle": "./src/vitest/lifecycle.mjs",
-    "./vitest/utils": "./src/vitest/utils.mjs",
+    "./core": "./lib/core/index.js",
+    "./vitest": "./interfaces/vitest-plugin.mjs",
     "./vitest/plugin": "./interfaces/vitest-plugin.mjs",
-    "./presets": "./src/presets/index.mjs"
+    "./vitest/setup": "./lib/vitest/setup.mjs",
+    "./vitest/hooks": "./lib/vitest/hooks.mjs",
+    "./presets": "./lib/presets/index.mjs"
   },
   "bin": {
     "testdriverai": "bin/testdriverai.js"
@@ -61,7 +59,7 @@
     "chalk": "^4.1.2",
     "cli-progress": "^3.12.0",
     "diff": "^8.0.2",
-    "dotenv": "^16.4.5",
+    "dotenv": "^16.6.1",
     "eventemitter2": "^6.4.9",
     "jimp": "^0.22.12",
     "js-yaml": "^4.1.0",
@@ -99,7 +97,8 @@
     "mocha": "^10.8.2",
     "node-addon-api": "^8.0.0",
     "prettier": "3.3.3",
-    "vitest": "^4.0.8"
+    "testdriverai": "^6.1.11",
+    "vitest": "^4.0.15"
   },
   "optionalDependencies": {
     "@esbuild/linux-x64": "^0.21.5"

package/sdk.d.ts

@@ -1014,13 +1014,26 @@ export default class TestDriverSDK {
    *
    * @example
    * // Simple execution
-   * await client.ai('Click the submit button');
+   * await client.act('Click the submit button');
    *
    * @example
    * // With validation loop
-   * const result = await client.ai('Fill out the contact form', { validateAndLoop: true });
+   * const result = await client.act('Fill out the contact form', { validateAndLoop: true });
    * console.log(result); // AI's final assessment
    */
+  act(
+    task: string,
+    options?: { validateAndLoop?: boolean },
+  ): Promise<string | void>;
+
+  /**
+   * @deprecated Use act() instead
+   * Execute a natural language task using AI
+   *
+   * @param task - Natural language description of what to do
+   * @param options - Execution options
+   * @returns Final AI response if validateAndLoop is true
+   */
   ai(
     task: string,
     options?: { validateAndLoop?: boolean },