feat: add uploadTimeout fixture

Author: gmegidish

packages/driver-mobile-use/src/driver.ts

@@ -1,6 +1,7 @@
 import { createReadStream, openSync, readSync, closeSync } from 'node:fs';
 import { stat } from 'node:fs/promises';
 import { basename } from 'node:path';
+import { Transform } from 'node:stream';
 import createDebug from 'debug';
 import type {
   AppInfo,
@@ -92,6 +93,7 @@ interface MobileUseDevicesResponse {
 export interface MobileUseDriverOptions {
   region?: string;
   apiKey?: string;
+  uploadTimeout?: number;
 }
 
 const VALID_PLATFORMS = new Set<string>(['ios', 'android']);
@@ -494,16 +496,36 @@ export class MobileUseDriver implements MobilewrightDriver {
     });
 
     debug('uploading %s to S3 (uploadId=%s)', filename, upload.uploadId);
-    const body = createReadStream(filePath);
-    const response = await fetch(upload.uploadUrl, {
-      method: 'PUT',
-      headers: {
-        'Content-Type': 'application/octet-stream',
-        'Content-Length': String(fileInfo.size),
+    let bytesUploaded = 0;
+    const tracker = new Transform({
+      transform(chunk: Buffer, _encoding, callback) {
+        bytesUploaded += chunk.length;
+        callback(null, chunk);
       },
-      body,
-      duplex: 'half',
-    } as RequestInit);
+    });
+    createReadStream(filePath).pipe(tracker);
+
+    const uploadTimeout = this.options.uploadTimeout ?? 300_000;
+    const progressInterval = setInterval(() => {
+      const pct = Math.round((bytesUploaded / fileInfo.size) * 100);
+      debug('upload progress %s: %d/%d bytes (%d%%)', filename, bytesUploaded, fileInfo.size, pct);
+    }, 10_000);
+
+    let response!: Response;
+    try {
+      response = await fetch(upload.uploadUrl, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/octet-stream',
+          'Content-Length': String(fileInfo.size),
+        },
+        body: tracker,
+        duplex: 'half',
+        signal: AbortSignal.timeout(uploadTimeout),
+      } as RequestInit);
+    } finally {
+      clearInterval(progressInterval);
+    }
     if (!response.ok) {
       throw new Error(`Upload failed with status ${response.status}`);
     }

packages/mobilewright-core/src/tracing.ts

@@ -27,6 +27,8 @@ interface BeforeActionEvent {
   class: string;
   method: string;
   params: Record<string, unknown>;
+  pageId?: string;
+  beforeSnapshot?: string;
   stepId?: string;
   parentId?: string;
   stack?: StackFrame[];
@@ -36,6 +38,7 @@ interface AfterActionEvent {
   type: 'after';
   callId: string;
   endTime: number;
+  afterSnapshot?: string;
   error?: { message: string; stack?: string };
   attachments?: TraceAttachment[];
 }
@@ -50,6 +53,30 @@ interface ScreencastFrameEvent {
   frameSwapWallTime?: number;
 }
 
+// NodeSnapshot uses Playwright's compact array format:
+//   string → text node
+//   [tagName] | [tagName, attrs, ...children] → element node
+type NodeSnapshot = string | unknown[];
+
+interface FrameSnapshotEvent {
+  type: 'frame-snapshot';
+  snapshot: {
+    snapshotName: string;
+    callId: string;
+    pageId: string;
+    frameId: string;
+    frameUrl: string;
+    timestamp: number;
+    wallTime: number;
+    collectionTime: number;
+    doctype: string;
+    html: NodeSnapshot;
+    resourceOverrides: Array<{ url: string; sha1: string }>;
+    viewport: { width: number; height: number };
+    isMainFrame: boolean;
+  };
+}
+
 interface ErrorEvent {
   type: 'error';
   message: string;
@@ -75,8 +102,11 @@ type TraceEvent =
   | BeforeActionEvent
   | AfterActionEvent
   | ScreencastFrameEvent
+  | FrameSnapshotEvent
   | ErrorEvent;
 
+type ScreenshotCapture = { sha1: string; width: number; height: number };
+
 // ─── Tracer ─────────────────────────────────────────────────────
 
 export class Tracer {
@@ -126,7 +156,7 @@ export class Tracer {
     return hash;
   }
 
-  private async captureScreenshot(): Promise<{ sha1: string; width: number; height: number } | null> {
+  private async captureScreenshot(): Promise<ScreenshotCapture | null> {
     if (!this.driver) {
       return null;
     }
@@ -167,6 +197,47 @@ export class Tracer {
     return frames;
   }
 
+  private pushScreencastFrame(shot: ScreenshotCapture): void {
+    this.events.push({
+      type: 'screencast-frame',
+      pageId: 'device@1',
+      sha1: shot.sha1,
+      width: shot.width,
+      height: shot.height,
+      timestamp: this.monotonicTime(),
+      frameSwapWallTime: Date.now(),
+    });
+  }
+
+  private pushFrameSnapshot(snapshotName: string, callId: string, shot: ScreenshotCapture): void {
+    this.events.push({
+      type: 'frame-snapshot',
+      snapshot: {
+        snapshotName,
+        callId,
+        pageId: 'device@1',
+        frameId: 'device@1',
+        frameUrl: 'mobilewright://device',
+        timestamp: this.monotonicTime(),
+        wallTime: Date.now(),
+        collectionTime: 0,
+        doctype: 'html',
+        html: [
+          'HTML', {},
+          ['HEAD', {},
+            ['STYLE', {}, 'body{margin:0;padding:0;background:#000}img{width:100%;height:100%;object-fit:contain;display:block}'],
+          ],
+          ['BODY', {},
+            ['IMG', { src: 'screenshot.png' }],
+          ],
+        ],
+        resourceOverrides: [{ url: 'screenshot.png', sha1: shot.sha1 }],
+        viewport: { width: shot.width, height: shot.height },
+        isMainFrame: true,
+      },
+    });
+  }
+
   async wrapAction<T>(
     className: string,
     method: string,
@@ -176,21 +247,12 @@ export class Tracer {
     const callId = this.nextCallId();
     const stack = this.captureStack();
 
-    // Before screenshot
-    const beforeScreenshot = await this.captureScreenshot();
-    if (beforeScreenshot) {
-      this.events.push({
-        type: 'screencast-frame',
-        pageId: 'device@1',
-        sha1: beforeScreenshot.sha1,
-        width: beforeScreenshot.width,
-        height: beforeScreenshot.height,
-        timestamp: this.monotonicTime(),
-        frameSwapWallTime: Date.now(),
-      });
+    const beforeShot = await this.captureScreenshot();
+    if (beforeShot) {
+      this.pushScreencastFrame(beforeShot);
+      this.pushFrameSnapshot(`before@${callId}`, callId, beforeShot);
     }
 
-    // Before event
     this.events.push({
       type: 'before',
       callId,
@@ -199,46 +261,32 @@ export class Tracer {
       method,
       params,
       stack,
+      pageId: 'device@1',
+      ...(beforeShot && { beforeSnapshot: `before@${callId}` }),
     });
 
     try {
       const result = await fn();
 
-      // After screenshot
-      const afterScreenshot = await this.captureScreenshot();
-      if (afterScreenshot) {
-        this.events.push({
-          type: 'screencast-frame',
-          pageId: 'device@1',
-          sha1: afterScreenshot.sha1,
-          width: afterScreenshot.width,
-          height: afterScreenshot.height,
-          timestamp: this.monotonicTime(),
-          frameSwapWallTime: Date.now(),
-        });
+      const afterShot = await this.captureScreenshot();
+      if (afterShot) {
+        this.pushScreencastFrame(afterShot);
+        this.pushFrameSnapshot(`after@${callId}`, callId, afterShot);
       }
 
-      // After event
       this.events.push({
         type: 'after',
         callId,
         endTime: this.monotonicTime(),
+        ...(afterShot && { afterSnapshot: `after@${callId}` }),
       });
 
       return result;
     } catch (error) {
-      // After screenshot on failure
-      const errorScreenshot = await this.captureScreenshot();
-      if (errorScreenshot) {
-        this.events.push({
-          type: 'screencast-frame',
-          pageId: 'device@1',
-          sha1: errorScreenshot.sha1,
-          width: errorScreenshot.width,
-          height: errorScreenshot.height,
-          timestamp: this.monotonicTime(),
-          frameSwapWallTime: Date.now(),
-        });
+      const errorShot = await this.captureScreenshot();
+      if (errorShot) {
+        this.pushScreencastFrame(errorShot);
+        this.pushFrameSnapshot(`after@${callId}`, callId, errorShot);
       }
 
       const err = error instanceof Error ? error : new Error(String(error));
@@ -247,6 +295,7 @@ export class Tracer {
         type: 'after',
         callId,
         endTime: this.monotonicTime(),
+        ...(errorShot && { afterSnapshot: `after@${callId}` }),
         error: {
           message: err.message,
           stack: err.stack,
@@ -262,19 +311,14 @@ export class Tracer {
 
     const zipFile = new yazl.ZipFile();
 
-    // Add trace events as NDJSON
     const traceContent = this.events.map(e => JSON.stringify(e)).join('\n');
     zipFile.addBuffer(Buffer.from(traceContent), 'trace.trace');
-
-    // Add empty network trace
     zipFile.addBuffer(Buffer.from(''), 'trace.network');
 
-    // Add screenshot resources
     for (const [sha1, data] of this.resources) {
       zipFile.addBuffer(data, `resources/${sha1}`);
     }
 
-    // Write ZIP to disk
     await new Promise<void>((resolve, reject) => {
       zipFile.end(undefined, () => {
         const stream = createWriteStream(outputPath);

packages/mobilewright/src/config.ts

@@ -93,6 +93,8 @@ export interface MobilewrightConfig {
   outputDir?: string;
   /** Global timeout for tests (ms). */
   timeout?: number;
+  /** Timeout for app uploads in milliseconds. Default: 300000 (5 minutes). */
+  uploadTimeout?: number;
   /** Global timeout for locators (ms). */
   actionTimeout?: number;
   /** Maximum retry count for flaky tests. */

packages/mobilewright/src/launchers.ts

@@ -30,6 +30,7 @@ export interface ConnectDeviceParams {
   driverConfig?: DriverConfig;
   url?: string;
   timeout?: number;
+  uploadTimeout?: number;
 }
 
 export interface FindDeviceParams {
@@ -40,11 +41,12 @@ export interface FindDeviceParams {
   url?: string;
 }
 
-export function createDriver(driverConfig?: DriverConfig, url?: string): MobilewrightDriver {
+export function createDriver(driverConfig?: DriverConfig, url?: string, uploadTimeout?: number): MobilewrightDriver {
   if (driverConfig?.type === 'mobile-use') {
     return new MobileUseDriver({
       region: driverConfig.region,
       apiKey: driverConfig.apiKey,
+      uploadTimeout,
     });
   }
   return new MobilecliDriver({ url });
@@ -54,7 +56,7 @@ export async function connectDevice(params: ConnectDeviceParams): Promise<Device
   // URL is baked into the driver at construction time; don't override it here.
   // Passing mobilecli's default URL into MobileUseDriver.connect() would send
   // requests to the wrong server.
-  const driver = createDriver(params.driverConfig, params.url);
+  const driver = createDriver(params.driverConfig, params.url, params.uploadTimeout);
   const device = new Device(driver);
   await device.connect({
     platform: params.platform,

packages/test/src/fixtures.ts

@@ -143,13 +143,16 @@ export const test = base.extend<MobilewrightTestFixtures>({
       driverConfig: merged.driver,
       url: merged.url,
       timeout: merged.timeout,
+      uploadTimeout: merged.uploadTimeout,
     });
     debug('connected to device %s', handle.deviceId);
 
     try {
+      const uploadTimeout = merged.uploadTimeout ?? 300_000;
       for (const appPath of toArray(merged.installApps)) {
         const installed = await client.isAppInstalled(handle.allocationId, appPath);
         if (!installed) {
+          testInfo.setTimeout(testInfo.timeout + uploadTimeout);
           await device.installApp(appPath);
           await client.recordAppInstalled(handle.allocationId, appPath);
         }
@@ -188,7 +191,7 @@ export const test = base.extend<MobilewrightTestFixtures>({
     }
 
     // ── Tracing ──────────────────────────────────────────────
-    const config = await loadConfig();
+    const config = await loadConfig(process.cwd(), testInfo.config.configFile);
     const traceMode: TraceMode = config.trace ?? 'off';
     const shouldTrace = traceMode === 'on'
       || traceMode === 'retain-on-failure'