testdriverai 7.3.40 → 7.3.41

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [7.3.41](https://github.com/testdriverai/testdriverai/compare/v7.3.40...v7.3.41) (2026-02-25)
+
+
+
 ## [7.3.40](https://github.com/testdriverai/testdriverai/compare/v7.3.39...v7.3.40) (2026-02-25)
 
 

package/lib/vitest/hooks.mjs

@@ -104,22 +104,25 @@ function serialiseConsoleArgs(args) {
 }
 
 /**
- * Forward a console message to every active sandbox client.
- * Called from the (single) console spy.
+ * Buffer a console message into every active client's local log buffer.
+ * Replaces the old forwardToAllSandboxes which sent data over websocket
+ * to the sandbox for dashcam file-log capture. Logs are now uploaded
+ * directly to S3 from the vitest client at cleanup time.
  */
-function forwardToAllSandboxes(args) {
+function bufferConsoleToClients(args, level) {
   if (_consoleSpy.activeClients.size === 0) return;
 
   const message = serialiseConsoleArgs(args);
-  const encoded = Buffer.from(message, "utf8").toString("base64");
 
   for (const client of _consoleSpy.activeClients) {
-    if (client.sandbox && client.sandbox.instanceSocketConnected) {
-      try {
-        client.sandbox.send({ type: "output", output: encoded });
-      } catch {
-        // fire-and-forget — don't let one broken socket block the others
-      }
+    if (client._logBuffer) {
+      client._logBuffer.push({
+        time: Date.now(),
+        line: message,
+        level: level || "log",
+        source: "console",
+        logFile: "console",
+      });
     }
   }
 }
@@ -146,16 +149,16 @@ function installConsoleSpy() {
     info: console.info.bind(console),
   };
 
-  const makeHandler = (originalFn) => (...args) => {
-    originalFn(...args);           // Let Vitest's reporter capture the output
-    forwardToAllSandboxes(args);   // Forward to all sandbox dashcam streams
+  const makeHandler = (originalFn, level) => (...args) => {
+    originalFn(...args);              // Let Vitest's reporter capture the output
+    bufferConsoleToClients(args, level); // Buffer into local log store for S3 upload
   };
 
   _consoleSpy.spies = {
-    log: vi.spyOn(console, "log").mockImplementation(makeHandler(_consoleSpy.originals.log)),
-    error: vi.spyOn(console, "error").mockImplementation(makeHandler(_consoleSpy.originals.error)),
-    warn: vi.spyOn(console, "warn").mockImplementation(makeHandler(_consoleSpy.originals.warn)),
-    info: vi.spyOn(console, "info").mockImplementation(makeHandler(_consoleSpy.originals.info)),
+    log: vi.spyOn(console, "log").mockImplementation(makeHandler(_consoleSpy.originals.log, "log")),
+    error: vi.spyOn(console, "error").mockImplementation(makeHandler(_consoleSpy.originals.error, "error")),
+    warn: vi.spyOn(console, "warn").mockImplementation(makeHandler(_consoleSpy.originals.warn, "warn")),
+    info: vi.spyOn(console, "info").mockImplementation(makeHandler(_consoleSpy.originals.info, "info")),
   };
 
   if (debugConsoleSpy) {
@@ -214,6 +217,110 @@ function cleanupConsoleSpy(client) {
 const testDriverInstances = new WeakMap();
 const lifecycleHandlers = new WeakMap();
 
+/**
+ * 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
+ * a Log record and get a presigned PUT URL, then uploads the JSONL payload.
+ *
+ * @param {import('../../sdk.js').default} client - TestDriver SDK instance
+ * @param {string|null} dashcamUrl - Dashcam replay URL from dashcam.stop()
+ */
+async function uploadLogsToReplay(client, dashcamUrl) {
+  if (!dashcamUrl) return;
+
+  // Extract replayId from the dashcam URL (e.g. https://app.dashcam.io/replay/6789abcdef012345...)
+  const replayMatch = dashcamUrl.match(/replay\/([a-f0-9]{24})/);
+  if (!replayMatch) {
+    if (debugConsoleSpy) {
+      console.log("[uploadLogsToReplay] Could not extract replayId from:", dashcamUrl);
+    }
+    return;
+  }
+
+  const replayId = replayMatch[1];
+  const logData = client.getLogs();
+
+  if (!logData || logData.trim().length === 0) {
+    if (debugConsoleSpy) {
+      console.log("[uploadLogsToReplay] No logs to upload");
+    }
+    return;
+  }
+
+  try {
+    // Get TD_API_KEY for auth (prefer SDK config which is always correctly resolved)
+    const apiKey = client.config?.TD_API_KEY || process.env.TD_API_KEY;
+    if (!apiKey) {
+      console.warn("[TestDriver] TD_API_KEY not set, skipping log upload");
+      return;
+    }
+
+    // Use the SDK's configured API root (matches what the SDK uses for all other API calls)
+    const apiRoot = client.config?.TD_API_ROOT || process.env.TD_API_ROOT || "https://testdriver-api.onrender.com";
+
+    console.log(`[TestDriver] Uploading logs for replay ${replayId} to ${apiRoot}...`);
+
+    const authRes = await fetch(`${apiRoot}/auth/exchange-api-key`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ apiKey }),
+    });
+
+    if (!authRes.ok) {
+      console.warn("[TestDriver] Failed to exchange API key for log upload:", authRes.status);
+      return;
+    }
+
+    const authData = await authRes.json();
+    const token = authData.token;
+
+    // Create a Log record and get presigned upload URL
+    const logCreateRes = await fetch(`${apiRoot}/api/v1/logs`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({
+        replayId,
+        appId: "testdriver-sdk",
+        name: "TestDriver Log",
+        type: "cli",
+      }),
+    });
+
+    if (!logCreateRes.ok) {
+      console.warn("[TestDriver] Failed to create log record:", logCreateRes.status);
+      return;
+    }
+
+    const logCreateData = await logCreateRes.json();
+    const uploadUrl = logCreateData.presignedUploadUrl;
+
+    if (!uploadUrl) {
+      console.warn("[TestDriver] No presigned upload URL returned from log-create");
+      return;
+    }
+
+    // Upload the JSONL log data directly to S3
+    const uploadRes = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: { "Content-Type": "application/x-ndjson" },
+      body: logData,
+    });
+
+    if (!uploadRes.ok) {
+      console.warn("[TestDriver] Failed to upload logs to S3:", uploadRes.status);
+      return;
+    }
+
+    console.log(`[TestDriver] ✅ Logs uploaded successfully for replay: ${replayId}`);
+  } catch (err) {
+    // Fire-and-forget — don't let log upload failure break the test
+    console.warn("[TestDriver] Log upload failed:", err.message);
+  }
+}
+
 /**
  * Create a TestDriver client in a Vitest test with automatic lifecycle management
  *
@@ -340,31 +447,16 @@ export function TestDriver(context, options = {}) {
       );
     }
 
-    // Only set up dashcam-related infrastructure if enabled (default: true)
-    if (testdriver.dashcamEnabled) {
-      // Set up console spy for dashcam visibility
-      setupConsoleSpy(testdriver, context.task.id);
-
-      // Create the log file on the remote machine
-      const shell = testdriver.os === "windows" ? "pwsh" : "sh";
-      const logPath =
-        testdriver.os === "windows"
-          ? "C:\\Users\\testdriver\\Documents\\testdriver.log"
-          : "/tmp/testdriver.log";
+    // Set up console spy for local log buffering (always, regardless of dashcam)
+    setupConsoleSpy(testdriver, context.task.id);
 
-      const createLogCmd =
-        testdriver.os === "windows"
-          ? `New-Item -ItemType File -Path "${logPath}" -Force | Out-Null`
-          : `touch ${logPath}`;
-
-      await testdriver.exec(shell, createLogCmd, 10000, true);
-
-      // Add testdriver log to dashcam tracking
-      await testdriver.dashcam.addFileLog(logPath, "TestDriver Log");
-
-      // Web log tracking and dashcam.start() are handled by provision.chrome()
-      // This ensures addWebLog is called with the domain pattern BEFORE dashcam.start()
-    }
+    // Note: We no longer create a log file on the sandbox or call dashcam.addFileLog().
+    // TestDriver logs are buffered locally in _logBuffer and uploaded directly to S3
+    // from the vitest client at cleanup time. This avoids the expensive path of
+    // forwarding logs over websocket → sandbox file → dashcam upload.
+    //
+    // Web log tracking and dashcam.start() are still handled by provision.chrome()
+    // This ensures addWebLog is called with the domain pattern BEFORE dashcam.start()
   })();
 
   // Register cleanup handler with dashcam.stop()
@@ -496,6 +588,10 @@ export function TestDriver(context, options = {}) {
             );
             console.log("");
           }
+
+          // Upload buffered logs directly to S3 via the existing Log system.
+          // This replaces the old path of forwarding logs to the sandbox for dashcam capture.
+          await uploadLogsToReplay(currentInstance, dashcamUrl);
         } catch (error) {
           // Log more detailed error information for debugging
           console.error(

package/package.json

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

package/sdk.js

@@ -1601,6 +1601,10 @@ class TestDriverSDK {
     // Set up logging if enabled (after emitter is exposed)
     this.loggingEnabled = options.logging !== false;
 
+    // Log buffer: structured entries collected during test execution.
+    // Uploaded to S3 at cleanup so they can be displayed alongside dashcam replays.
+    this._logBuffer = [];
+
     // Set up event listeners once (they live for the lifetime of the SDK instance)
     this._setupLogging();
 
@@ -3797,7 +3801,7 @@ CAPTCHA_SOLVER_EOF`,
 
     // Set up basic event logging
     // Note: We only console.log here - the console spy in vitest/hooks.mjs
-    // handles forwarding to sandbox. This prevents duplicate output to server.
+    // handles forwarding to the local log buffer.
     this.emitter.on("log:**", (message) => {
       const event = this.emitter.event;
 
@@ -3812,6 +3816,21 @@ CAPTCHA_SOLVER_EOF`,
           : message;
         console.log(prefixedMessage);
       }
+
+      // Buffer structured SDK log for later upload
+      if (message) {
+        const level = event === events.log.warn ? "warn"
+          : event === events.log.debug ? "debug"
+          : "info";
+        this._logBuffer.push({
+          time: Date.now(),
+          line: String(message),
+          level,
+          source: "sdk",
+          event,
+          logFile: "sdk",
+        });
+      }
     });
 
     this.emitter.on("error:**", (data) => {
@@ -3824,12 +3843,34 @@ CAPTCHA_SOLVER_EOF`,
           lastFatalError = data;
         }
       }
+
+      // Buffer error events for later upload
+      this._logBuffer.push({
+        time: Date.now(),
+        line: `${this.emitter.event}: ${data}`,
+        level: "error",
+        source: "sdk",
+        event: this.emitter.event,
+        logFile: "sdk",
+      });
     });
 
     this.emitter.on("status", (message) => {
       if (this.loggingEnabled) {
         console.log(`- ${message}`);
       }
+
+      // Buffer status events
+      if (message) {
+        this._logBuffer.push({
+          time: Date.now(),
+          line: `- ${message}`,
+          level: "info",
+          source: "sdk",
+          event: "status",
+          logFile: "sdk",
+        });
+      }
     });
 
     // Handle exit events - throw error with meaningful message instead of calling process.exit
@@ -4206,6 +4247,26 @@ CAPTCHA_SOLVER_EOF`,
   async ai(task, options) {
     return await this.act(task, options);
   }
+
+  /**
+   * Get buffered logs as a JSONL string for upload.
+   * Each line is a JSON object with { time, line, level, source, event }.
+   * @returns {string} JSONL-formatted log data
+   */
+  getLogs() {
+    if (this._logBuffer.length === 0) return "";
+    const startTime = this._logBuffer[0].time;
+    return this._logBuffer
+      .map((entry) => JSON.stringify({ ...entry, time: entry.time - startTime }))
+      .join("\n");
+  }
+
+  /**
+   * Clear the internal log buffer.
+   */
+  clearLogs() {
+    this._logBuffer = [];
+  }
 }
 
 // Expose SDK version as a static property for use by vitest hooks/plugins