testlens-playwright-reporter 0.2.6 → 0.2.8

package/index.d.ts

@@ -11,6 +11,10 @@ export interface TestLensReporterConfig {
   enableGitInfo?: boolean;
   /** Enable artifact processing */
   enableArtifacts?: boolean;
+  /** Enable video capture - defaults to true */
+  enableVideo?: boolean;
+  /** Enable screenshot capture - defaults to true */
+  enableScreenshot?: boolean;
   /** Batch size for API requests */
   batchSize?: number;
   /** Flush interval in milliseconds */
@@ -36,6 +40,10 @@ export interface TestLensReporterOptions {
   enableGitInfo?: boolean;
   /** Enable artifact processing */
   enableArtifacts?: boolean;
+  /** Enable video capture - defaults to true */
+  enableVideo?: boolean;
+  /** Enable screenshot capture - defaults to true */
+  enableScreenshot?: boolean;
   /** Batch size for API requests */
   batchSize?: number;
   /** Flush interval in milliseconds */
@@ -62,6 +70,46 @@ export interface GitInfo {
   remoteUrl: string;
 }
 
+/** Rich error details from Playwright */
+export interface TestError {
+  message: string;
+  stack?: string;
+  location?: {
+    file: string;
+    line: number;
+    column: number;
+  };
+  snippet?: string;
+  expected?: string;
+  actual?: string;
+  diff?: string;
+  matcherName?: string;
+  timeout?: number;
+}
+
+export interface TestData {
+  id: string;
+  name: string;
+  status: string;
+  originalStatus?: string;
+  duration: number;
+  startTime: string;
+  endTime: string;
+  errorMessages: string[];
+  errors?: TestError[];
+  retryAttempts: number;
+  currentRetry: number;
+  annotations: Array<{ type: string; description?: string }>;
+  projectName: string;
+  workerIndex?: number;
+  parallelIndex?: number;
+  location?: {
+    file: string;
+    line: number;
+    column: number;
+  };
+}
+
 export default class TestLensReporter implements Reporter {
   constructor(options: TestLensReporterOptions);
   

package/index.js

@@ -27,6 +27,8 @@ class TestLensReporter {
       enableRealTimeStream: options.enableRealTimeStream !== undefined ? options.enableRealTimeStream : true,
       enableGitInfo: options.enableGitInfo !== undefined ? options.enableGitInfo : true,
       enableArtifacts: options.enableArtifacts !== undefined ? options.enableArtifacts : true,
+      enableVideo: options.enableVideo !== undefined ? options.enableVideo : true, // Default to true, override from config
+      enableScreenshot: options.enableScreenshot !== undefined ? options.enableScreenshot : true, // Default to true, override from config
       batchSize: options.batchSize || 10,
       flushInterval: options.flushInterval || 5000,
       retryAttempts: options.retryAttempts !== undefined ? options.retryAttempts : 0,
@@ -211,6 +213,7 @@ class TestLensReporter {
         startTime: new Date().toISOString(),
         endTime: '',
         errorMessages: [],
+        errors: [],
         retryAttempts: test.retries,
         currentRetry: result.retry,
         annotations: test.annotations.map(ann => ({
@@ -219,7 +222,12 @@ class TestLensReporter {
         })),
         projectName: test.parent.project()?.name || 'default',
         workerIndex: result.workerIndex,
-        parallelIndex: result.parallelIndex
+        parallelIndex: result.parallelIndex,
+        location: {
+          file: path.relative(process.cwd(), test.location.file),
+          line: test.location.line,
+          column: test.location.column
+        }
       };
 
       this.testMap.set(testData.id, testData);
@@ -252,6 +260,96 @@ class TestLensReporter {
       testData.endTime = new Date().toISOString();
       testData.errorMessages = result.errors.map(error => error.message || error.toString());
       testData.currentRetry = result.retry;
+      
+      // Capture test location
+      testData.location = {
+        file: path.relative(process.cwd(), test.location.file),
+        line: test.location.line,
+        column: test.location.column
+      };
+      
+      // Capture rich error details like Playwright's HTML report
+      testData.errors = result.errors.map(error => {
+        const testError = {
+          message: error.message || error.toString()
+        };
+        
+        // Capture stack trace
+        if (error.stack) {
+          testError.stack = error.stack;
+        }
+        
+        // Capture error location
+        if (error.location) {
+          testError.location = {
+            file: path.relative(process.cwd(), error.location.file),
+            line: error.location.line,
+            column: error.location.column
+          };
+        }
+        
+        // Capture code snippet around error - from Playwright error object
+        if (error.snippet) {
+          testError.snippet = error.snippet;
+        }
+        
+        // Capture expected/actual values for assertion failures
+        // Playwright stores these as specially formatted strings in the message
+        const message = error.message || '';
+        
+        // Try to parse expected pattern from toHaveURL and similar assertions
+        const expectedPatternMatch = message.match(/Expected pattern:\s*(.+?)(?:\n|$)/);
+        if (expectedPatternMatch) {
+          testError.expected = expectedPatternMatch[1].trim();
+        }
+        
+        // Also try "Expected string:" format
+        if (!testError.expected) {
+          const expectedStringMatch = message.match(/Expected string:\s*["']?(.+?)["']?(?:\n|$)/);
+          if (expectedStringMatch) {
+            testError.expected = expectedStringMatch[1].trim();
+          }
+        }
+        
+        // Try to parse received/actual value
+        const receivedMatch = message.match(/Received (?:string|value):\s*["']?(.+?)["']?(?:\n|$)/);
+        if (receivedMatch) {
+          testError.actual = receivedMatch[1].trim();
+        }
+        
+        // Parse call log entries for debugging info (timeouts, retries, etc.)
+        const callLogMatch = message.match(/Call log:([\s\S]*?)(?=\n\n|\n\s*\d+\s*\||$)/);
+        if (callLogMatch) {
+          // Store call log separately for display
+          const callLog = callLogMatch[1].trim();
+          if (callLog) {
+            testError.diff = callLog; // Reuse diff field for call log
+          }
+        }
+        
+        // Parse timeout information - multiple formats
+        const timeoutMatch = message.match(/(?:with timeout|Timeout:?)\s*(\d+)ms/i);
+        if (timeoutMatch) {
+          testError.timeout = parseInt(timeoutMatch[1], 10);
+        }
+        
+        // Parse matcher name (e.g., toHaveURL, toBeVisible)
+        const matcherMatch = message.match(/expect\([^)]+\)\.(\w+)/);
+        if (matcherMatch) {
+          testError.matcherName = matcherMatch[1];
+        }
+        
+        // Extract code snippet from message if not already captured
+        // Look for lines like "  9 |      await page.click..." or "> 11 |      await expect..."
+        if (!testError.snippet) {
+          const codeSnippetMatch = message.match(/((?:\s*>?\s*\d+\s*\|.*\n?)+)/);
+          if (codeSnippetMatch) {
+            testError.snippet = codeSnippetMatch[1].trim();
+          }
+        }
+        
+        return testError;
+      });
 
       // Only send testEnd event after final retry attempt
       // If test passed or this is the last retry, send the event
@@ -316,8 +414,10 @@ class TestLensReporter {
     // Calculate final stats
     const totalTests = Array.from(this.testMap.values()).length;
     const passedTests = Array.from(this.testMap.values()).filter(t => t.status === 'passed').length;
+    // failedTests already includes timedOut tests since normalizeTestStatus converts 'timedOut' to 'failed'
     const failedTests = Array.from(this.testMap.values()).filter(t => t.status === 'failed').length;
     const skippedTests = Array.from(this.testMap.values()).filter(t => t.status === 'skipped').length;
+    // Track timedOut separately for reporting purposes only (not for count)
     const timedOutTests = Array.from(this.testMap.values()).filter(t => t.originalStatus === 'timedOut').length;
 
     // Normalize run status - if there are timeouts, treat run as failed
@@ -333,9 +433,9 @@ class TestLensReporter {
         ...this.runMetadata,
         totalTests,
         passedTests,
-        failedTests: failedTests + timedOutTests, // Include timeouts in failed count
+        failedTests, // Already includes timedOut tests (normalized to 'failed')
         skippedTests,
-        timedOutTests,
+        timedOutTests, // For informational purposes
         status: normalizedRunStatus
       }
     });
@@ -345,7 +445,7 @@ class TestLensReporter {
     await new Promise(resolve => setTimeout(resolve, 10000));
 
     console.log(`📊 TestLens Report completed - Run ID: ${this.runId}`);
-    console.log(`🎯 Results: ${passedTests} passed, ${failedTests + timedOutTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
+    console.log(`🎯 Results: ${passedTests} passed, ${failedTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
   }
 
   async sendToApi(payload) {
@@ -386,17 +486,70 @@ class TestLensReporter {
         for (let i = 0; i < attachments.length; i++) {
           const attachment = attachments[i];
           if (attachment.path) {
+            // Check if attachment should be processed based on config
+            const artifactType = this.getArtifactType(attachment.name);
+            const isVideo = artifactType === 'video' || (attachment.contentType && attachment.contentType.startsWith('video/'));
+            const isScreenshot = artifactType === 'screenshot' || (attachment.contentType && attachment.contentType.startsWith('image/'));
+            
+            // Skip video if disabled in config
+            if (isVideo && !this.config.enableVideo) {
+              console.log(`⏭️  Skipping video artifact ${attachment.name} - video capture disabled in config`);
+              continue;
+            }
+            
+            // Skip screenshot if disabled in config
+            if (isScreenshot && !this.config.enableScreenshot) {
+              console.log(`⏭️  Skipping screenshot artifact ${attachment.name} - screenshot capture disabled in config`);
+              continue;
+            }
+            
             try {
               console.log(`📤 Processing ${attachment.name} asynchronously...`);
               
+              // Determine proper filename with extension
+              // Playwright attachment.name often doesn't have extension, so we need to derive it
+              let fileName = attachment.name;
+              const existingExt = path.extname(fileName);
+              
+              if (!existingExt) {
+                // Get extension from the actual file path
+                const pathExt = path.extname(attachment.path);
+                if (pathExt) {
+                  fileName = `${fileName}${pathExt}`;
+                } else if (attachment.contentType) {
+                  // Fallback: derive extension from contentType
+                  const mimeToExt = {
+                    'image/png': '.png',
+                    'image/jpeg': '.jpg',
+                    'image/gif': '.gif',
+                    'image/webp': '.webp',
+                    'video/webm': '.webm',
+                    'video/mp4': '.mp4',
+                    'application/zip': '.zip',
+                    'application/json': '.json',
+                    'text/plain': '.txt'
+                  };
+                  const ext = mimeToExt[attachment.contentType];
+                  if (ext) {
+                    fileName = `${fileName}${ext}`;
+                  }
+                }
+              }
+              
               // Upload to S3 first
-              const s3Data = await this.uploadArtifactToS3(attachment.path, testId, attachment.name);
+              const s3Data = await this.uploadArtifactToS3(attachment.path, testId, fileName);
+              
+              // Skip if upload failed or file was too large
+              if (!s3Data) {
+                console.log(`⏭️  Skipping artifact ${attachment.name} - upload failed or file too large`);
+                continue;
+              }
               
               const artifactData = {
                 testId,
                 type: this.getArtifactType(attachment.name),
                 path: attachment.path,
-                name: attachment.name,
+                name: fileName,
                 contentType: attachment.contentType,
                 fileSize: this.getFileSize(attachment.path),
                 storageType: 's3',
@@ -412,7 +565,7 @@ class TestLensReporter {
                 artifact: artifactData
               });
 
-              console.log(`📎 Processed artifact: ${attachment.name} (uploaded to S3)`);
+              console.log(`📎 Processed artifact: ${fileName} (uploaded to S3)`);
             } catch (error) {
               console.error(`❌ Failed to process ${attachment.name}:`, error.message);
             }

package/index.ts

@@ -32,6 +32,10 @@ export interface TestLensReporterConfig {
   enableGitInfo?: boolean;
   /** Enable artifact processing */
   enableArtifacts?: boolean;
+  /** Enable video capture - defaults to true */
+  enableVideo?: boolean;
+  /** Enable screenshot capture - defaults to true */
+  enableScreenshot?: boolean;
   /** Batch size for API requests */
   batchSize?: number;
   /** Flush interval in milliseconds */
@@ -57,6 +61,10 @@ export interface TestLensReporterOptions {
   enableGitInfo?: boolean;
   /** Enable artifact processing */
   enableArtifacts?: boolean;
+  /** Enable video capture - defaults to true */
+  enableVideo?: boolean;
+  /** Enable screenshot capture - defaults to true */
+  enableScreenshot?: boolean;
   /** Batch size for API requests */
   batchSize?: number;
   /** Flush interval in milliseconds */
@@ -115,6 +123,22 @@ export interface RunMetadata {
   status?: string;
 }
 
+export interface TestError {
+  message: string;
+  stack?: string;
+  location?: {
+    file: string;
+    line: number;
+    column: number;
+  };
+  snippet?: string;
+  expected?: string;
+  actual?: string;
+  diff?: string;
+  matcherName?: string;
+  timeout?: number;
+}
+
 export interface TestData {
   id: string;
   name: string;
@@ -124,12 +148,18 @@ export interface TestData {
   startTime: string;
   endTime: string;
   errorMessages: string[];
+  errors?: TestError[]; // Rich error details
   retryAttempts: number;
   currentRetry: number;
   annotations: Array<{ type: string; description?: string }>;
   projectName: string;
   workerIndex?: number;
   parallelIndex?: number;
+  location?: {
+    file: string;
+    line: number;
+    column: number;
+  };
 }
 
 export interface SpecData {
@@ -156,6 +186,8 @@ export class TestLensReporter implements Reporter {
       enableRealTimeStream: options.enableRealTimeStream !== undefined ? options.enableRealTimeStream : true,
       enableGitInfo: options.enableGitInfo !== undefined ? options.enableGitInfo : true,
       enableArtifacts: options.enableArtifacts !== undefined ? options.enableArtifacts : true,
+      enableVideo: options.enableVideo !== undefined ? options.enableVideo : true, // Default to true, override from config
+      enableScreenshot: options.enableScreenshot !== undefined ? options.enableScreenshot : true, // Default to true, override from config
       batchSize: options.batchSize || 10,
       flushInterval: options.flushInterval || 5000,
       retryAttempts: options.retryAttempts !== undefined ? options.retryAttempts : 0,
@@ -340,6 +372,7 @@ export class TestLensReporter implements Reporter {
         startTime: new Date().toISOString(),
         endTime: '',
         errorMessages: [],
+        errors: [],
         retryAttempts: test.retries,
         currentRetry: result.retry,
         annotations: test.annotations.map((ann: any) => ({
@@ -348,7 +381,12 @@ export class TestLensReporter implements Reporter {
         })),
         projectName: test.parent.project()?.name || 'default',
         workerIndex: result.workerIndex,
-        parallelIndex: result.parallelIndex
+        parallelIndex: result.parallelIndex,
+        location: {
+          file: path.relative(process.cwd(), test.location.file),
+          line: test.location.line,
+          column: test.location.column
+        }
       };
 
       this.testMap.set(testData.id, testData);
@@ -381,6 +419,96 @@ export class TestLensReporter implements Reporter {
       testData.endTime = new Date().toISOString();
       testData.errorMessages = result.errors.map((error: any) => error.message || error.toString());
       testData.currentRetry = result.retry;
+      
+      // Capture test location
+      testData.location = {
+        file: path.relative(process.cwd(), test.location.file),
+        line: test.location.line,
+        column: test.location.column
+      };
+      
+      // Capture rich error details like Playwright's HTML report
+      testData.errors = result.errors.map((error: any) => {
+        const testError: TestError = {
+          message: error.message || error.toString()
+        };
+        
+        // Capture stack trace
+        if (error.stack) {
+          testError.stack = error.stack;
+        }
+        
+        // Capture error location
+        if (error.location) {
+          testError.location = {
+            file: path.relative(process.cwd(), error.location.file),
+            line: error.location.line,
+            column: error.location.column
+          };
+        }
+        
+        // Capture code snippet around error - from Playwright error object
+        if (error.snippet) {
+          testError.snippet = error.snippet;
+        }
+        
+        // Capture expected/actual values for assertion failures
+        // Playwright stores these as specially formatted strings in the message
+        const message = error.message || '';
+        
+        // Try to parse expected pattern from toHaveURL and similar assertions
+        const expectedPatternMatch = message.match(/Expected pattern:\s*(.+?)(?:\n|$)/);
+        if (expectedPatternMatch) {
+          testError.expected = expectedPatternMatch[1].trim();
+        }
+        
+        // Also try "Expected string:" format
+        if (!testError.expected) {
+          const expectedStringMatch = message.match(/Expected string:\s*["']?(.+?)["']?(?:\n|$)/);
+          if (expectedStringMatch) {
+            testError.expected = expectedStringMatch[1].trim();
+          }
+        }
+        
+        // Try to parse received/actual value
+        const receivedMatch = message.match(/Received (?:string|value):\s*["']?(.+?)["']?(?:\n|$)/);
+        if (receivedMatch) {
+          testError.actual = receivedMatch[1].trim();
+        }
+        
+        // Parse call log entries for debugging info (timeouts, retries, etc.)
+        const callLogMatch = message.match(/Call log:([\s\S]*?)(?=\n\n|\n\s*\d+\s*\||$)/);
+        if (callLogMatch) {
+          // Store call log separately for display
+          const callLog = callLogMatch[1].trim();
+          if (callLog) {
+            testError.diff = callLog; // Reuse diff field for call log
+          }
+        }
+        
+        // Parse timeout information - multiple formats
+        const timeoutMatch = message.match(/(?:with timeout|Timeout:?)\s*(\d+)ms/i);
+        if (timeoutMatch) {
+          testError.timeout = parseInt(timeoutMatch[1], 10);
+        }
+        
+        // Parse matcher name (e.g., toHaveURL, toBeVisible)
+        const matcherMatch = message.match(/expect\([^)]+\)\.(\w+)/);
+        if (matcherMatch) {
+          testError.matcherName = matcherMatch[1];
+        }
+        
+        // Extract code snippet from message if not already captured
+        // Look for lines like "  9 |      await page.click..." or "> 11 |      await expect..."
+        if (!testError.snippet) {
+          const codeSnippetMatch = message.match(/((?:\s*>?\s*\d+\s*\|.*\n?)+)/);
+          if (codeSnippetMatch) {
+            testError.snippet = codeSnippetMatch[1].trim();
+          }
+        }
+        
+        return testError;
+      });
 
       // Only send testEnd event after final retry attempt
       // If test passed or this is the last retry, send the event
@@ -445,8 +573,10 @@ export class TestLensReporter implements Reporter {
     // Calculate final stats
     const totalTests = Array.from(this.testMap.values()).length;
     const passedTests = Array.from(this.testMap.values()).filter(t => t.status === 'passed').length;
+    // failedTests already includes timedOut tests since normalizeTestStatus converts 'timedOut' to 'failed'
     const failedTests = Array.from(this.testMap.values()).filter(t => t.status === 'failed').length;
     const skippedTests = Array.from(this.testMap.values()).filter(t => t.status === 'skipped').length;
+    // Track timedOut separately for reporting purposes only (not for count)
     const timedOutTests = Array.from(this.testMap.values()).filter(t => t.originalStatus === 'timedOut').length;
 
     // Normalize run status - if there are timeouts, treat run as failed
@@ -462,15 +592,15 @@ export class TestLensReporter implements Reporter {
         ...this.runMetadata,
         totalTests,
         passedTests,
-        failedTests: failedTests + timedOutTests, // Include timeouts in failed count
+        failedTests, // Already includes timedOut tests (normalized to 'failed')
         skippedTests,
-        timedOutTests,
+        timedOutTests, // For informational purposes
         status: normalizedRunStatus
       }
     });
 
     console.log(`📊 TestLens Report completed - Run ID: ${this.runId}`);
-    console.log(`🎯 Results: ${passedTests} passed, ${failedTests + timedOutTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
+    console.log(`🎯 Results: ${passedTests} passed, ${failedTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
   }
 
   private async sendToApi(payload: any): Promise<void> {
@@ -500,9 +630,56 @@ export class TestLensReporter implements Reporter {
     
     for (const attachment of attachments) {
       if (attachment.path) {
+        // Check if attachment should be processed based on config
+        const artifactType = this.getArtifactType(attachment.name);
+        const isVideo = artifactType === 'video' || attachment.contentType?.startsWith('video/');
+        const isScreenshot = artifactType === 'screenshot' || attachment.contentType?.startsWith('image/');
+        
+        // Skip video if disabled in config
+        if (isVideo && !this.config.enableVideo) {
+          console.log(`⏭️  Skipping video artifact ${attachment.name} - video capture disabled in config`);
+          continue;
+        }
+        
+        // Skip screenshot if disabled in config
+        if (isScreenshot && !this.config.enableScreenshot) {
+          console.log(`⏭️  Skipping screenshot artifact ${attachment.name} - screenshot capture disabled in config`);
+          continue;
+        }
+        
         try {
+          // Determine proper filename with extension
+          // Playwright attachment.name often doesn't have extension, so we need to derive it
+          let fileName = attachment.name;
+          const existingExt = path.extname(fileName);
+          
+          if (!existingExt) {
+            // Get extension from the actual file path
+            const pathExt = path.extname(attachment.path);
+            if (pathExt) {
+              fileName = `${fileName}${pathExt}`;
+            } else if (attachment.contentType) {
+              // Fallback: derive extension from contentType
+              const mimeToExt: Record<string, string> = {
+                'image/png': '.png',
+                'image/jpeg': '.jpg',
+                'image/gif': '.gif',
+                'image/webp': '.webp',
+                'video/webm': '.webm',
+                'video/mp4': '.mp4',
+                'application/zip': '.zip',
+                'application/json': '.json',
+                'text/plain': '.txt'
+              };
+              const ext = mimeToExt[attachment.contentType];
+              if (ext) {
+                fileName = `${fileName}${ext}`;
+              }
+            }
+          }
+
           // Upload to S3 first
-          const s3Data = await this.uploadArtifactToS3(attachment.path, testId, attachment.name);
+          const s3Data = await this.uploadArtifactToS3(attachment.path, testId, fileName);
           
           // Skip if upload failed or file was too large
           if (!s3Data) {
@@ -514,7 +691,7 @@ export class TestLensReporter implements Reporter {
             testId,
             type: this.getArtifactType(attachment.name),
             path: attachment.path,
-            name: attachment.name,
+            name: fileName,
             contentType: attachment.contentType,
             fileSize: this.getFileSize(attachment.path),
             storageType: 's3',
@@ -530,7 +707,7 @@ export class TestLensReporter implements Reporter {
             artifact: artifactData
           });
           
-          console.log(`📎 Processed artifact: ${attachment.name} (uploaded to S3)`);
+          console.log(`📎 Processed artifact: ${fileName} (uploaded to S3)`);
         } catch (error) {
           console.error(`❌ Failed to process artifact ${attachment.name}:`, (error as Error).message);
         }

package/lib/index.js

@@ -63,6 +63,8 @@ class TestLensReporter {
             enableRealTimeStream: options.enableRealTimeStream !== undefined ? options.enableRealTimeStream : true,
             enableGitInfo: options.enableGitInfo !== undefined ? options.enableGitInfo : true,
             enableArtifacts: options.enableArtifacts !== undefined ? options.enableArtifacts : true,
+            enableVideo: options.enableVideo !== undefined ? options.enableVideo : true, // Default to true, override from config
+            enableScreenshot: options.enableScreenshot !== undefined ? options.enableScreenshot : true, // Default to true, override from config
             batchSize: options.batchSize || 10,
             flushInterval: options.flushInterval || 5000,
             retryAttempts: options.retryAttempts !== undefined ? options.retryAttempts : 0,
@@ -227,6 +229,7 @@ class TestLensReporter {
                 startTime: new Date().toISOString(),
                 endTime: '',
                 errorMessages: [],
+                errors: [],
                 retryAttempts: test.retries,
                 currentRetry: result.retry,
                 annotations: test.annotations.map((ann) => ({
@@ -235,7 +238,12 @@ class TestLensReporter {
                 })),
                 projectName: test.parent.project()?.name || 'default',
                 workerIndex: result.workerIndex,
-                parallelIndex: result.parallelIndex
+                parallelIndex: result.parallelIndex,
+                location: {
+                    file: path.relative(process.cwd(), test.location.file),
+                    line: test.location.line,
+                    column: test.location.column
+                }
             };
             this.testMap.set(testData.id, testData);
             // Send test start event to API
@@ -265,6 +273,82 @@ class TestLensReporter {
             testData.endTime = new Date().toISOString();
             testData.errorMessages = result.errors.map((error) => error.message || error.toString());
             testData.currentRetry = result.retry;
+            // Capture test location
+            testData.location = {
+                file: path.relative(process.cwd(), test.location.file),
+                line: test.location.line,
+                column: test.location.column
+            };
+            // Capture rich error details like Playwright's HTML report
+            testData.errors = result.errors.map((error) => {
+                const testError = {
+                    message: error.message || error.toString()
+                };
+                // Capture stack trace
+                if (error.stack) {
+                    testError.stack = error.stack;
+                }
+                // Capture error location
+                if (error.location) {
+                    testError.location = {
+                        file: path.relative(process.cwd(), error.location.file),
+                        line: error.location.line,
+                        column: error.location.column
+                    };
+                }
+                // Capture code snippet around error - from Playwright error object
+                if (error.snippet) {
+                    testError.snippet = error.snippet;
+                }
+                // Capture expected/actual values for assertion failures
+                // Playwright stores these as specially formatted strings in the message
+                const message = error.message || '';
+                // Try to parse expected pattern from toHaveURL and similar assertions
+                const expectedPatternMatch = message.match(/Expected pattern:\s*(.+?)(?:\n|$)/);
+                if (expectedPatternMatch) {
+                    testError.expected = expectedPatternMatch[1].trim();
+                }
+                // Also try "Expected string:" format
+                if (!testError.expected) {
+                    const expectedStringMatch = message.match(/Expected string:\s*["']?(.+?)["']?(?:\n|$)/);
+                    if (expectedStringMatch) {
+                        testError.expected = expectedStringMatch[1].trim();
+                    }
+                }
+                // Try to parse received/actual value
+                const receivedMatch = message.match(/Received (?:string|value):\s*["']?(.+?)["']?(?:\n|$)/);
+                if (receivedMatch) {
+                    testError.actual = receivedMatch[1].trim();
+                }
+                // Parse call log entries for debugging info (timeouts, retries, etc.)
+                const callLogMatch = message.match(/Call log:([\s\S]*?)(?=\n\n|\n\s*\d+\s*\||$)/);
+                if (callLogMatch) {
+                    // Store call log separately for display
+                    const callLog = callLogMatch[1].trim();
+                    if (callLog) {
+                        testError.diff = callLog; // Reuse diff field for call log
+                    }
+                }
+                // Parse timeout information - multiple formats
+                const timeoutMatch = message.match(/(?:with timeout|Timeout:?)\s*(\d+)ms/i);
+                if (timeoutMatch) {
+                    testError.timeout = parseInt(timeoutMatch[1], 10);
+                }
+                // Parse matcher name (e.g., toHaveURL, toBeVisible)
+                const matcherMatch = message.match(/expect\([^)]+\)\.(\w+)/);
+                if (matcherMatch) {
+                    testError.matcherName = matcherMatch[1];
+                }
+                // Extract code snippet from message if not already captured
+                // Look for lines like "  9 |      await page.click..." or "> 11 |      await expect..."
+                if (!testError.snippet) {
+                    const codeSnippetMatch = message.match(/((?:\s*>?\s*\d+\s*\|.*\n?)+)/);
+                    if (codeSnippetMatch) {
+                        testError.snippet = codeSnippetMatch[1].trim();
+                    }
+                }
+                return testError;
+            });
             // Only send testEnd event after final retry attempt
             // If test passed or this is the last retry, send the event
             const isFinalAttempt = result.status === 'passed' || result.status === 'skipped' || result.retry >= test.retries;
@@ -320,8 +404,10 @@ class TestLensReporter {
         // Calculate final stats
         const totalTests = Array.from(this.testMap.values()).length;
         const passedTests = Array.from(this.testMap.values()).filter(t => t.status === 'passed').length;
+        // failedTests already includes timedOut tests since normalizeTestStatus converts 'timedOut' to 'failed'
         const failedTests = Array.from(this.testMap.values()).filter(t => t.status === 'failed').length;
         const skippedTests = Array.from(this.testMap.values()).filter(t => t.status === 'skipped').length;
+        // Track timedOut separately for reporting purposes only (not for count)
         const timedOutTests = Array.from(this.testMap.values()).filter(t => t.originalStatus === 'timedOut').length;
         // Normalize run status - if there are timeouts, treat run as failed
         const hasTimeouts = timedOutTests > 0;
@@ -335,14 +421,14 @@ class TestLensReporter {
                 ...this.runMetadata,
                 totalTests,
                 passedTests,
-                failedTests: failedTests + timedOutTests, // Include timeouts in failed count
+                failedTests, // Already includes timedOut tests (normalized to 'failed')
                 skippedTests,
-                timedOutTests,
+                timedOutTests, // For informational purposes
                 status: normalizedRunStatus
             }
         });
         console.log(`📊 TestLens Report completed - Run ID: ${this.runId}`);
-        console.log(`🎯 Results: ${passedTests} passed, ${failedTests + timedOutTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
+        console.log(`🎯 Results: ${passedTests} passed, ${failedTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
     }
     async sendToApi(payload) {
         try {
@@ -369,9 +455,52 @@ class TestLensReporter {
         const attachments = result.attachments;
         for (const attachment of attachments) {
             if (attachment.path) {
+                // Check if attachment should be processed based on config
+                const artifactType = this.getArtifactType(attachment.name);
+                const isVideo = artifactType === 'video' || attachment.contentType?.startsWith('video/');
+                const isScreenshot = artifactType === 'screenshot' || attachment.contentType?.startsWith('image/');
+                // Skip video if disabled in config
+                if (isVideo && !this.config.enableVideo) {
+                    console.log(`⏭️  Skipping video artifact ${attachment.name} - video capture disabled in config`);
+                    continue;
+                }
+                // Skip screenshot if disabled in config
+                if (isScreenshot && !this.config.enableScreenshot) {
+                    console.log(`⏭️  Skipping screenshot artifact ${attachment.name} - screenshot capture disabled in config`);
+                    continue;
+                }
                 try {
+                    // Determine proper filename with extension
+                    // Playwright attachment.name often doesn't have extension, so we need to derive it
+                    let fileName = attachment.name;
+                    const existingExt = path.extname(fileName);
+                    if (!existingExt) {
+                        // Get extension from the actual file path
+                        const pathExt = path.extname(attachment.path);
+                        if (pathExt) {
+                            fileName = `${fileName}${pathExt}`;
+                        }
+                        else if (attachment.contentType) {
+                            // Fallback: derive extension from contentType
+                            const mimeToExt = {
+                                'image/png': '.png',
+                                'image/jpeg': '.jpg',
+                                'image/gif': '.gif',
+                                'image/webp': '.webp',
+                                'video/webm': '.webm',
+                                'video/mp4': '.mp4',
+                                'application/zip': '.zip',
+                                'application/json': '.json',
+                                'text/plain': '.txt'
+                            };
+                            const ext = mimeToExt[attachment.contentType];
+                            if (ext) {
+                                fileName = `${fileName}${ext}`;
+                            }
+                        }
+                    }
                     // Upload to S3 first
-                    const s3Data = await this.uploadArtifactToS3(attachment.path, testId, attachment.name);
+                    const s3Data = await this.uploadArtifactToS3(attachment.path, testId, fileName);
                     // Skip if upload failed or file was too large
                     if (!s3Data) {
                         console.log(`⏭️  Skipping artifact ${attachment.name} - upload failed or file too large`);
@@ -381,7 +510,7 @@ class TestLensReporter {
                         testId,
                         type: this.getArtifactType(attachment.name),
                         path: attachment.path,
-                        name: attachment.name,
+                        name: fileName,
                         contentType: attachment.contentType,
                         fileSize: this.getFileSize(attachment.path),
                         storageType: 's3',
@@ -395,7 +524,7 @@ class TestLensReporter {
                         timestamp: new Date().toISOString(),
                         artifact: artifactData
                     });
-                    console.log(`📎 Processed artifact: ${attachment.name} (uploaded to S3)`);
+                    console.log(`📎 Processed artifact: ${fileName} (uploaded to S3)`);
                 }
                 catch (error) {
                     console.error(`❌ Failed to process artifact ${attachment.name}:`, error.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testlens-playwright-reporter",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Universal Playwright reporter for TestLens - works with both TypeScript and JavaScript projects",
   "main": "index.js",
   "types": "index.d.ts",