testlens-playwright-reporter 0.3.2 → 0.3.4

package/index.js

@@ -1,919 +1,1097 @@
-const { randomUUID } = require('crypto');
-const os = require('os');
-const path = require('path');
-const fs = require('fs');
-const https = require('https');
-const axios = require('axios');
-const FormData = require('form-data');
-
-// Lazy-load mime module to support ESM
-let mimeModule = null;
-async function getMime() {
-  if (!mimeModule) {
-    const imported = await import('mime');
-    // Handle both default export and named exports
-    mimeModule = imported.default || imported;
-  }
-  return mimeModule;
-}
-
-class TestLensReporter {
-  constructor(options = {}) {
-    this.config = {
-      apiEndpoint: options.apiEndpoint || 'https://testlens.qa-path.com/api/v1/webhook/playwright',
-      apiKey: options.apiKey, // API key must come from config file
-      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,
-      timeout: options.timeout || 60000
-    };
-
-    if (!this.config.apiKey) {
-      throw new Error('API_KEY is required for TestLensReporter. Pass it as apiKey option in your playwright config.');
-    }
-
-    // Determine SSL validation behavior
-    let rejectUnauthorized = true; // Default to secure
-
-    // Check various ways SSL validation can be disabled (in order of precedence)
-    if (this.config.ignoreSslErrors) {
-      // Explicit configuration option
-      rejectUnauthorized = false;
-    } else if (this.config.rejectUnauthorized === false) {
-      // Explicit configuration option
-      rejectUnauthorized = false;
-    } else if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0') {
-      // Environment variable override
-      rejectUnauthorized = false;
-    }
-
-    // Set up axios instance with retry logic and enhanced SSL handling
-    this.axiosInstance = axios.create({
-      baseURL: this.config.apiEndpoint,
-      timeout: this.config.timeout,
-      headers: {
-        'Content-Type': 'application/json',
-        ...(this.config.apiKey && { 'X-API-Key': this.config.apiKey }),
-      },
-      // Enhanced SSL handling with flexible TLS configuration
-      httpsAgent: new https.Agent({
-        rejectUnauthorized: rejectUnauthorized,
-        // Allow any TLS version for better compatibility
-        minVersion: 'TLSv1.2',
-        maxVersion: 'TLSv1.3'
-      })
-    });
-
-    // Add retry interceptor
-    this.axiosInstance.interceptors.response.use(
-      (response) => response,
-      async (error) => {
-        const originalRequest = error.config;
-        
-        if (!originalRequest._retry && error.response?.status >= 500) {
-          originalRequest._retry = true;
-          originalRequest._retryCount = (originalRequest._retryCount || 0) + 1;
-          
-          if (originalRequest._retryCount <= this.config.retryAttempts) {
-            // Exponential backoff
-            const delay = Math.pow(2, originalRequest._retryCount) * 1000;
-            await new Promise(resolve => setTimeout(resolve, delay));
-            return this.axiosInstance(originalRequest);
-          }
-        }
-        
-        return Promise.reject(error);
-      }
-    );
-
-    this.runId = randomUUID();
-    this.runMetadata = this.initializeRunMetadata();
-    this.specMap = new Map();
-    this.testMap = new Map();
-  }
-
-  initializeRunMetadata() {
-    return {
-      id: this.runId,
-      startTime: new Date().toISOString(),
-      environment: process.env.NODE_ENV || 'development',
-      browser: 'multiple',
-      os: `${os.type()} ${os.release()}`,
-      playwrightVersion: this.getPlaywrightVersion(),
-      nodeVersion: process.version
-    };
-  }
-
-  getPlaywrightVersion() {
-    try {
-      const playwrightPackage = require('@playwright/test/package.json');
-      return playwrightPackage.version;
-    } catch (error) {
-      return 'unknown';
-    }
-  }
-
-  normalizeTestStatus(status) {
-    // Treat timeout as failed for consistency with analytics
-    if (status === 'timedOut') {
-      return 'failed';
-    }
-    return status;
-  }
-
-  normalizeRunStatus(status, hasTimeouts) {
-    // If run has timeouts, treat as failed
-    if (hasTimeouts && status === 'passed') {
-      return 'failed';
-    }
-    // Treat timeout status as failed
-    if (status === 'timedOut') {
-      return 'failed';
-    }
-    return status;
-  }
-
-  async onBegin(config, suite) {
-    // Collect Git information if enabled
-    if (this.config.enableGitInfo) {
-      this.runMetadata.gitInfo = await this.collectGitInfo();
-    }
-
-    // Add shard information if available
-    if (config.shard) {
-      this.runMetadata.shardInfo = {
-        current: config.shard.current,
-        total: config.shard.total
-      };
-    }
-
-    // Send run start event to API
-    await this.sendToApi({
-      type: 'runStart',
-      runId: this.runId,
-      timestamp: new Date().toISOString(),
-      metadata: this.runMetadata
-    });
-  }
-
-  async onTestBegin(test, result) {
-    const specPath = test.location.file;
-    const specKey = `${specPath}-${test.parent.title}`;
-
-    // Create or update spec data
-    if (!this.specMap.has(specKey)) {
-      const specData = {
-        filePath: path.relative(process.cwd(), specPath),
-        testSuiteName: test.parent.title,
-        tags: this.extractTags(test),
-        startTime: new Date().toISOString(),
-        status: 'running'
-      };
-      this.specMap.set(specKey, specData);
-
-      // Send spec start event to API
-      await this.sendToApi({
-        type: 'specStart',
-        runId: this.runId,
-        timestamp: new Date().toISOString(),
-        spec: specData
-      });
-    }
-
-    const testId = this.getTestId(test);
-    
-    // Only send testStart event on first attempt (retry 0)
-    if (result.retry === 0) {
-      // Create test data
-      const testData = {
-        id: testId,
-        name: test.title,
-        status: 'running',
-        originalStatus: 'running',
-        duration: 0,
-        startTime: new Date().toISOString(),
-        endTime: '',
-        errorMessages: [],
-        errors: [],
-        retryAttempts: test.retries,
-        currentRetry: result.retry,
-        annotations: test.annotations.map(ann => ({
-          type: ann.type,
-          description: ann.description
-        })),
-        projectName: test.parent.project()?.name || 'default',
-        workerIndex: result.workerIndex,
-        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
-      await this.sendToApi({
-        type: 'testStart',
-        runId: this.runId,
-        timestamp: new Date().toISOString(),
-        test: testData
-      });
-    } else {
-      // For retries, just update the existing test data
-      const existingTestData = this.testMap.get(testId);
-      if (existingTestData) {
-        existingTestData.currentRetry = result.retry;
-      }
-    }
-  }
-
-  async onTestEnd(test, result) {
-    const testId = this.getTestId(test);
-    let testData = this.testMap.get(testId);
-
-    // For skipped tests, onTestBegin might not be called, so we need to create the test data here
-    if (!testData) {
-      // Create spec data if not exists (skipped tests might not have spec data either)
-      const specPath = test.location.file;
-      const specKey = `${specPath}-${test.parent.title}`;
-      
-      if (!this.specMap.has(specKey)) {
-        const specData = {
-          filePath: path.relative(process.cwd(), specPath),
-          testSuiteName: test.parent.title,
-          tags: this.extractTags(test),
-          startTime: new Date().toISOString(),
-          status: 'skipped'
-        };
-        this.specMap.set(specKey, specData);
-
-        // Send spec start event to API
-        await this.sendToApi({
-          type: 'specStart',
-          runId: this.runId,
-          timestamp: new Date().toISOString(),
-          spec: specData
-        });
-      }
-
-      // Create test data for skipped test
-      testData = {
-        id: testId,
-        name: test.title,
-        status: 'skipped',
-        originalStatus: 'skipped',
-        duration: 0,
-        startTime: new Date().toISOString(),
-        endTime: new Date().toISOString(),
-        errorMessages: [],
-        errors: [],
-        retryAttempts: test.retries,
-        currentRetry: 0,
-        annotations: test.annotations.map(ann => ({
-          type: ann.type,
-          description: ann.description
-        })),
-        projectName: test.parent.project()?.name || 'default',
-        workerIndex: result.workerIndex,
-        parallelIndex: result.parallelIndex,
-        location: {
-          file: path.relative(process.cwd(), test.location.file),
-          line: test.location.line,
-          column: test.location.column
-        }
-      };
-
-      this.testMap.set(testId, testData);
-
-      // Send test start event first (so the test gets created in DB)
-      await this.sendToApi({
-        type: 'testStart',
-        runId: this.runId,
-        timestamp: new Date().toISOString(),
-        test: testData
-      });
-    }
-
-    if (testData) {
-      // Update test data with latest result
-      testData.originalStatus = result.status;
-      testData.status = this.normalizeTestStatus(result.status);
-      testData.duration = result.duration;
-      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;
-      
-      if (isFinalAttempt) {
-        // Send test end event to API
-        await this.sendToApi({
-          type: 'testEnd',
-          runId: this.runId,
-          timestamp: new Date().toISOString(),
-          test: testData
-        });
-
-        // Handle artifacts
-        if (this.config.enableArtifacts) {
-          await this.processArtifacts(testId, result);
-        }
-      }
-    }
-
-    // Update spec status
-    const specPath = test.location.file;
-    const specKey = `${specPath}-${test.parent.title}`;
-    const specData = this.specMap.get(specKey);
-    if (specData) {
-      const normalizedStatus = this.normalizeTestStatus(result.status);
-      if (normalizedStatus === 'failed' && specData.status !== 'failed') {
-        specData.status = 'failed';
-      } else if (result.status === 'skipped' && specData.status === 'passed') {
-        specData.status = 'skipped';
-      }
-
-      // Check if all tests in spec are complete
-      const remainingTests = test.parent.tests.filter(t => {
-        const tId = this.getTestId(t);
-        const tData = this.testMap.get(tId);
-        return !tData || !tData.endTime;
-      });
-
-      if (remainingTests.length === 0) {
-        specData.endTime = new Date().toISOString();
-        
-        // Send spec end event to API
-        await this.sendToApi({
-          type: 'specEnd',
-          runId: this.runId,
-          timestamp: new Date().toISOString(),
-          spec: specData
-        });
-
-        // Send spec code blocks to API
-        await this.sendSpecCodeBlocks(specPath);
-      }
-    }
-  }
-
-  async onEnd(result) {
-    this.runMetadata.endTime = new Date().toISOString();
-    this.runMetadata.duration = Date.now() - new Date(this.runMetadata.startTime).getTime();
-
-    // 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;
-    const normalizedRunStatus = this.normalizeRunStatus(result.status, hasTimeouts);
-
-    // Send run end event to API
-    await this.sendToApi({
-      type: 'runEnd',
-      runId: this.runId,
-      timestamp: new Date().toISOString(),
-      metadata: {
-        ...this.runMetadata,
-        totalTests,
-        passedTests,
-        failedTests, // Already includes timedOut tests (normalized to 'failed')
-        skippedTests,
-        timedOutTests, // For informational purposes
-        status: normalizedRunStatus
-      }
-    });
-
-    // Wait for background artifact processing to complete (up to 10 seconds)
-    await new Promise(resolve => setTimeout(resolve, 10000));
-  }
-
-  async sendToApi(payload) {
-    try {
-      const response = await this.axiosInstance.post('', payload, {
-        headers: {
-          'X-API-Key': this.config.apiKey
-        }
-      });
-    } catch (error) {
-      console.error(`❌ Failed to send ${payload.type} event to TestLens:`, {
-        message: error?.message || 'Unknown error',
-        status: error?.response?.status,
-        data: error?.response?.data
-      });
-      
-      // Don't throw error to avoid breaking test execution
-    }
-  }
-
-  async processArtifacts(testId, result) {
-    const attachments = result.attachments;
-
-    // Process artifacts with controlled async handling to ensure uploads complete
-    if (attachments && attachments.length > 0) {
-      // Process all artifacts asynchronously but track completion
-
-      // Use process.nextTick to defer processing to next event loop iteration
-      process.nextTick(async () => {
-        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) {
-              continue;
-            }
-            
-            // Skip screenshot if disabled in config
-            if (isScreenshot && !this.config.enableScreenshot) {
-              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, fileName);
-              
-              // Skip if upload failed or file was too large
-              if (!s3Data) {
-                continue;
-              }
-              
-              const artifactData = {
-                testId,
-                type: this.getArtifactType(attachment.name),
-                path: attachment.path,
-                name: fileName,
-                contentType: attachment.contentType,
-                fileSize: this.getFileSize(attachment.path),
-                storageType: 's3',
-                s3Key: s3Data.key,
-                s3Url: s3Data.url
-              };
-
-              // Send artifact data to API
-              await this.sendToApi({
-                type: 'artifact',
-                runId: this.runId,
-                timestamp: new Date().toISOString(),
-                artifact: artifactData
-              });
-            } catch (error) {
-              console.error(`❌ Failed to process ${attachment.name}:`, error.message);
-            }
-          }
-        }
-      });
-    }
-  }
-
-  async sendSpecCodeBlocks(specPath) {
-    try {
-      // Extract code blocks using built-in parser
-      const testBlocks = this.extractTestBlocks(specPath);
-      
-      // Transform blocks to match backend API expectations
-      const codeBlocks = testBlocks.map(block => ({
-        type: block.type,           // 'test' or 'describe'
-        name: block.name,           // test/describe name
-        content: block.content,     // full code content
-        summary: null,              // optional
-        describe: block.describe    // parent describe block name
-      }));
-      
-      // Send to dedicated spec code blocks API endpoint
-      const baseUrl = this.config.apiEndpoint.replace('/webhook/playwright', '');
-      const specEndpoint = `${baseUrl}/webhook/playwright/spec-code-blocks`;
-      
-      await this.axiosInstance.post(specEndpoint, {
-        filePath: path.relative(process.cwd(), specPath),
-        codeBlocks,
-        testSuiteName: path.basename(specPath).replace(/\.(spec|test)\.(js|ts)$/, '')
-      });
-    } catch (error) {
-      console.error('Failed to send spec code blocks:', error?.response?.data || error?.message || 'Unknown error');
-    }
-  }
-
-  extractTestBlocks(filePath) {
-    try {
-      const content = fs.readFileSync(filePath, 'utf-8');
-      const blocks = [];
-      const lines = content.split('\n');
-      
-      let currentDescribe = null;
-      let braceCount = 0;
-      let inBlock = false;
-      let blockStart = -1;
-      let blockType = '';
-      let blockName = '';
-      
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const trimmedLine = line.trim();
-        
-        // Check for describe blocks
-        const describeMatch = trimmedLine.match(/describe\s*\(\s*['"`]([^'"`]+)['"`]/);
-        if (describeMatch) {
-          currentDescribe = describeMatch[1];
-        }
-        
-        // Check for test blocks
-        const testMatch = trimmedLine.match(/test\s*\(\s*['"`]([^'"`]+)['"`]/);
-        if (testMatch && !inBlock) {
-          blockType = 'test';
-          blockName = testMatch[1];
-          blockStart = i;
-          braceCount = 0;
-          inBlock = true;
-        }
-        
-        // Count braces when in a block
-        if (inBlock) {
-          for (const char of line) {
-            if (char === '{') braceCount++;
-            if (char === '}') braceCount--;
-            
-            if (braceCount === 0 && blockStart !== -1 && i > blockStart) {
-              // End of block found
-              const blockContent = lines.slice(blockStart, i + 1).join('\n');
-              
-              blocks.push({
-                type: blockType,
-                name: blockName,
-                content: blockContent,
-                describe: currentDescribe,
-                startLine: blockStart + 1,
-                endLine: i + 1
-              });
-              
-              inBlock = false;
-              blockStart = -1;
-              break;
-            }
-          }
-        }
-      }
-      
-      return blocks;
-    } catch (error) {
-      console.error(`Failed to extract test blocks from ${filePath}:`, error.message);
-      return [];
-    }
-  }
-
-  async collectGitInfo() {
-    try {
-      const { execSync } = require('child_process');
-      
-      const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
-      const commit = execSync('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
-      const shortCommit = commit.substring(0, 7);
-      const author = execSync('git log -1 --pretty=format:"%an"', { encoding: 'utf-8' }).trim();
-      const commitMessage = execSync('git log -1 --pretty=format:"%s"', { encoding: 'utf-8' }).trim();
-      const commitTimestamp = execSync('git log -1 --pretty=format:"%ci"', { encoding: 'utf-8' }).trim();
-      
-      let remoteName = 'origin';
-      let remoteUrl = '';
-      try {
-        const remotes = execSync('git remote', { encoding: 'utf-8' }).trim();
-        if (remotes) {
-          remoteName = remotes.split('\n')[0] || 'origin';
-          remoteUrl = execSync(`git remote get-url ${remoteName}`, { encoding: 'utf-8' }).trim();
-        }
-      } catch (e) {
-        // Remote info is optional - handle gracefully
-      }
-      
-      const isDirty = execSync('git status --porcelain', { encoding: 'utf-8' }).trim().length > 0;
-      
-      return {
-        branch,
-        commit,
-        shortCommit,
-        author,
-        message: commitMessage,
-        timestamp: commitTimestamp,
-        isDirty,
-        remoteName,
-        remoteUrl
-      };
-    } catch (error) {
-      console.warn('Could not collect Git information:', error.message);
-      return null;
-    }
-  }
-
-  getArtifactType(name) {
-    if (name.includes('screenshot')) return 'screenshot';
-    if (name.includes('video')) return 'video';
-    if (name.includes('trace')) return 'trace';
-    return 'attachment';
-  }
-
-  extractTags(test) {
-    const tags = [];
-    
-    test.annotations.forEach(annotation => {
-      if (annotation.type === 'tag' && annotation.description) {
-        tags.push(annotation.description);
-      }
-    });
-
-    const tagMatches = test.title.match(/@[\w-]+/g);
-    if (tagMatches) {
-      tags.push(...tagMatches);
-    }
-
-    return tags;
-  }
-
-  getTestId(test) {
-    const cleanTitle = test.title.replace(/@[\w-]+/g, '').trim();
-    // Normalize path separators to forward slashes for cross-platform consistency
-    const normalizedFile = test.location.file.replace(/\\/g, '/');
-    return `${normalizedFile}:${test.location.line}:${cleanTitle}`;
-  }
-
-  getFileSize(filePath) {
-    try {
-      const stats = fs.statSync(filePath);
-      return stats.size;
-    } catch (error) {
-      console.warn(`Could not get file size for ${filePath}:`, error.message);
-      return 0;
-    }
-  }
-
-  async uploadArtifactToS3(filePath, testId, fileName) {
-    try {
-      // Check file size first
-      const fileSize = this.getFileSize(filePath);
-      const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);
-
-      const baseUrl = this.config.apiEndpoint.replace('/api/v1/webhook/playwright', '');
-      
-      // Step 1: Request pre-signed URL from server
-      const presignedUrlEndpoint = `${baseUrl}/api/v1/artifacts/public/presigned-url`;
-      const presignedResponse = await this.axiosInstance.post(presignedUrlEndpoint, {
-        apiKey: this.config.apiKey,
-        testRunId: this.runId,
-        testId: testId,
-        fileName: fileName,
-        fileType: await this.getContentType(fileName),
-        fileSize: fileSize,
-        artifactType: this.getArtifactType(fileName)
-      }, {
-        timeout: 10000 // Quick timeout for metadata request
-      });
-
-      if (!presignedResponse.data.success) {
-        throw new Error(`Failed to get presigned URL: ${presignedResponse.data.error || 'Unknown error'}`);
-      }
-
-      const { uploadUrl, s3Key, metadata } = presignedResponse.data;
-      
-      // Step 2: Upload directly to S3 using presigned URL
-      const fileBuffer = fs.readFileSync(filePath);
-      
-      // IMPORTANT: When using presigned URLs, we MUST include exactly the headers that were signed
-      // The backend signs with ServerSideEncryption:'AES256', so we must send that header
-      // AWS presigned URLs are very strict about header matching
-      const uploadResponse = await axios.put(uploadUrl, fileBuffer, {
-        headers: {
-          'x-amz-server-side-encryption': 'AES256'
-        },
-        maxContentLength: Infinity,
-        maxBodyLength: Infinity,
-        timeout: Math.max(600000, Math.ceil(fileSize / (1024 * 1024)) * 10000), // 10s per MB, min 10 minutes - increased for large trace files
-        // Don't use custom HTTPS agent for S3 uploads
-        httpsAgent: undefined
-      });
-
-      if (uploadResponse.status !== 200) {
-        throw new Error(`S3 upload failed with status ${uploadResponse.status}`);
-      }
-
-      // Step 3: Confirm upload with server to save metadata
-      const confirmEndpoint = `${baseUrl}/api/v1/artifacts/public/confirm-upload`;
-      const confirmResponse = await this.axiosInstance.post(confirmEndpoint, {
-        apiKey: this.config.apiKey,
-        testRunId: this.runId,
-        testId: testId,
-        s3Key: s3Key,
-        fileName: fileName,
-        fileType: await this.getContentType(fileName),
-        fileSize: fileSize,
-        artifactType: this.getArtifactType(fileName)
-      }, {
-        timeout: 10000
-      });
-
-      if (confirmResponse.status === 201 && confirmResponse.data.success) {
-        const artifact = confirmResponse.data.artifact;
-        return {
-          key: s3Key,
-          url: artifact.s3Url,
-          presignedUrl: artifact.presignedUrl,
-          fileSize: artifact.fileSize,
-          contentType: artifact.contentType
-        };
-      } else {
-        throw new Error(`Upload confirmation failed: ${confirmResponse.data.error || 'Unknown error'}`);
-      }
-    } catch (error) {
-      // Better error messages for common issues
-      let errorMsg = error.message;
-      
-      if (error.code === 'ECONNABORTED' && error.message.includes('timeout')) {
-        errorMsg = `Upload timeout - file may be too large or connection is slow`;
-      } else if (error.response?.status === 413) {
-        errorMsg = `File too large (413) - server rejected the upload`;
-      } else if (error.response?.status === 400) {
-        errorMsg = `Bad request (400) - ${error.response.data?.error || 'check file format'}`;
-      } else if (error.response?.status === 403) {
-        errorMsg = `Access denied (403) - presigned URL may have expired`;
-      }
-      
-      console.error(`❌ Failed to upload ${fileName} to S3:`, errorMsg);
-      if (error.response?.data) {
-        console.error('Error details:', error.response.data);
-      }
-      
-      // Don't throw, just return null to continue with other artifacts
-      return null;
-    }
-  }
-
-  async getContentType(fileName) {
-    const ext = path.extname(fileName).toLowerCase();
-    try {
-      const mime = await getMime();
-      // Try different ways to access getType method
-      const getType = mime.getType || mime.default?.getType;
-      if (typeof getType === 'function') {
-        const mimeType = getType.call(mime, ext) || getType.call(mime.default, ext);
-        return mimeType || 'application/octet-stream';
-      }
-    } catch (error) {
-      console.warn(`Failed to get MIME type for ${fileName}:`, error.message);
-    }
-    // Fallback to basic content type mapping
-    const contentTypes = {
-      '.mp4': 'video/mp4',
-      '.webm': 'video/webm',
-      '.png': 'image/png',
-      '.jpg': 'image/jpeg',
-      '.jpeg': 'image/jpeg',
-      '.gif': 'image/gif',
-      '.json': 'application/json',
-      '.txt': 'text/plain',
-      '.html': 'text/html',
-      '.xml': 'application/xml',
-      '.zip': 'application/zip',
-      '.pdf': 'application/pdf'
-    };
-    return contentTypes[ext] || 'application/octet-stream';
-  }
-}
-
-module.exports = TestLensReporter;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestLensReporter = void 0;
+const tslib_1 = require("tslib");
+const crypto_1 = require("crypto");
+const os = tslib_1.__importStar(require("os"));
+const path = tslib_1.__importStar(require("path"));
+const fs = tslib_1.__importStar(require("fs"));
+const https = tslib_1.__importStar(require("https"));
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const child_process_1 = require("child_process");
+// Lazy-load mime module to support ESM
+let mimeModule = null;
+async function getMime() {
+    if (!mimeModule) {
+        const imported = await Promise.resolve().then(() => tslib_1.__importStar(require('mime')));
+        // Handle both default export and named exports
+        mimeModule = imported.default || imported;
+    }
+    return mimeModule;
+}
+class TestLensReporter {
+    /**
+     * Parse custom metadata from environment variables
+     * Checks for common metadata environment variables
+     */
+    static parseCustomArgs() {
+        const customArgs = {};
+        // Common environment variable names for build metadata
+        const envVarMappings = {
+            'testlensBuildTag': ['BUILDTAG', 'BUILD_TAG', 'TestlensBuildTag'],
+            'testlensBuildName': ['BUILDNAME', 'BUILD_NAME', 'TestlensBuildName'],
+            'environment': ['ENVIRONMENT', 'ENV', 'NODE_ENV', 'DEPLOYMENT_ENV'],
+            'branch': ['BRANCH', 'GIT_BRANCH', 'CI_COMMIT_BRANCH', 'GITHUB_REF_NAME'],
+            'team': ['TEAM', 'TEAM_NAME'],
+            'project': ['PROJECT', 'PROJECT_NAME'],
+            'customvalue': ['CUSTOMVALUE', 'CUSTOM_VALUE']
+        };
+        // Check for each metadata key
+        Object.entries(envVarMappings).forEach(([key, envVars]) => {
+            for (const envVar of envVars) {
+                const value = process.env[envVar];
+                if (value) {
+                    customArgs[key] = value;
+                    console.log(`✓ Found ${envVar}=${value} (mapped to '${key}')`);
+                    break; // Use first match
+                }
+            }
+        });
+        return customArgs;
+    }
+    constructor(options) {
+        this.runCreationFailed = false; // Track if run creation failed due to limits
+        // Parse custom CLI arguments
+        const customArgs = TestLensReporter.parseCustomArgs();
+        // Allow API key from environment variable if not provided in config
+        // Check multiple environment variable names in priority order (uppercase and lowercase)
+        const apiKey = options.apiKey
+            || process.env.TESTLENS_API_KEY
+            || process.env.testlens_api_key
+            || process.env.TESTLENS_KEY
+            || process.env.testlens_key
+            || process.env.testlensApiKey
+            || process.env.PLAYWRIGHT_API_KEY
+            || process.env.playwright_api_key
+            || process.env.PW_API_KEY
+            || process.env.pw_api_key;
+        this.config = {
+            apiEndpoint: options.apiEndpoint || 'https://testlens.qa-path.com/api/v1/webhook/playwright',
+            apiKey: apiKey, // API key from config or environment variable
+            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,
+            timeout: options.timeout || 60000,
+            customMetadata: { ...customArgs, ...options.customMetadata } // CLI args + config metadata
+        };
+        if (!this.config.apiKey) {
+            throw new Error('API_KEY is required for TestLensReporter. Pass it as apiKey option in your playwright config or set one of these environment variables: TESTLENS_API_KEY, TESTLENS_KEY, PLAYWRIGHT_API_KEY, PW_API_KEY, API_KEY, or APIKEY.');
+        }
+        if (apiKey !== options.apiKey) {
+            console.log('✓ Using API key from environment variable');
+        }
+        // Determine SSL validation behavior
+        let rejectUnauthorized = true; // Default to secure
+        // Check various ways SSL validation can be disabled (in order of precedence)
+        if (this.config.ignoreSslErrors) {
+            // Explicit configuration option
+            rejectUnauthorized = false;
+            console.log('⚠️  SSL certificate validation disabled via ignoreSslErrors option');
+        }
+        else if (this.config.rejectUnauthorized === false) {
+            // Explicit configuration option
+            rejectUnauthorized = false;
+            console.log('⚠️  SSL certificate validation disabled via rejectUnauthorized option');
+        }
+        else if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0') {
+            // Environment variable override
+            rejectUnauthorized = false;
+            console.log('⚠️  SSL certificate validation disabled via NODE_TLS_REJECT_UNAUTHORIZED environment variable');
+        }
+        // Set up axios instance with retry logic and enhanced SSL handling
+        this.axiosInstance = axios_1.default.create({
+            baseURL: this.config.apiEndpoint,
+            timeout: this.config.timeout,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.config.apiKey && { 'X-API-Key': this.config.apiKey }),
+            },
+            // Enhanced SSL handling with flexible TLS configuration
+            httpsAgent: new https.Agent({
+                rejectUnauthorized: rejectUnauthorized,
+                // Allow any TLS version for better compatibility
+                minVersion: 'TLSv1.2',
+                maxVersion: 'TLSv1.3'
+            })
+        });
+        // Add retry interceptor
+        this.axiosInstance.interceptors.response.use((response) => response, async (error) => {
+            const originalRequest = error.config;
+            if (!originalRequest._retry && error.response?.status >= 500) {
+                originalRequest._retry = true;
+                originalRequest._retryCount = (originalRequest._retryCount || 0) + 1;
+                if (originalRequest._retryCount <= this.config.retryAttempts) {
+                    // Exponential backoff
+                    const delay = Math.pow(2, originalRequest._retryCount) * 1000;
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    return this.axiosInstance(originalRequest);
+                }
+            }
+            return Promise.reject(error);
+        });
+        this.runId = (0, crypto_1.randomUUID)();
+        this.runMetadata = this.initializeRunMetadata();
+        this.specMap = new Map();
+        this.testMap = new Map();
+        this.runCreationFailed = false;
+        // Log custom metadata if any
+        if (this.config.customMetadata && Object.keys(this.config.customMetadata).length > 0) {
+            console.log('\n📋 Custom Metadata Detected:');
+            Object.entries(this.config.customMetadata).forEach(([key, value]) => {
+                console.log(`   ${key}: ${value}`);
+            });
+            console.log('');
+        }
+    }
+    initializeRunMetadata() {
+        const metadata = {
+            id: this.runId,
+            startTime: new Date().toISOString(),
+            environment: 'production',
+            browser: 'multiple',
+            os: `${os.type()} ${os.release()}`,
+            playwrightVersion: this.getPlaywrightVersion(),
+            nodeVersion: process.version
+        };
+        // Add custom metadata if provided
+        if (this.config.customMetadata && Object.keys(this.config.customMetadata).length > 0) {
+            metadata.customMetadata = this.config.customMetadata;
+            // Extract testlensBuildName as a dedicated field for dashboard display
+            if (this.config.customMetadata.testlensBuildName) {
+                metadata.testlensBuildName = this.config.customMetadata.testlensBuildName;
+            }
+        }
+        return metadata;
+    }
+    getPlaywrightVersion() {
+        try {
+            const playwrightPackage = require('@playwright/test/package.json');
+            return playwrightPackage.version;
+        }
+        catch (error) {
+            return 'unknown';
+        }
+    }
+    normalizeTestStatus(status) {
+        // Treat timeout as failed for consistency with analytics
+        if (status === 'timedOut') {
+            return 'failed';
+        }
+        return status;
+    }
+    normalizeRunStatus(status, hasTimeouts) {
+        // If run has timeouts, treat as failed
+        if (hasTimeouts && status === 'passed') {
+            return 'failed';
+        }
+        // Treat timeout status as failed
+        if (status === 'timedOut') {
+            return 'failed';
+        }
+        return status;
+    }
+    async onBegin(config, suite) {
+        // Show Build Name if provided, otherwise show Run ID
+        if (this.runMetadata.testlensBuildName) {
+            console.log(`🚀 TestLens Reporter starting - Build: ${this.runMetadata.testlensBuildName}`);
+            console.log(`   Run ID: ${this.runId}`);
+        }
+        else {
+            console.log(`🚀 TestLens Reporter starting - Run ID: ${this.runId}`);
+        }
+        // Collect Git information if enabled
+        if (this.config.enableGitInfo) {
+            this.runMetadata.gitInfo = await this.collectGitInfo();
+            if (this.runMetadata.gitInfo) {
+                console.log(`📦 Git info collected: branch=${this.runMetadata.gitInfo.branch}, commit=${this.runMetadata.gitInfo.shortCommit}, author=${this.runMetadata.gitInfo.author}`);
+            }
+            else {
+                console.log(`⚠️  Git info collection returned null - not in a git repository or git not available`);
+            }
+        }
+        else {
+            console.log(`ℹ️  Git info collection disabled (enableGitInfo: false)`);
+        }
+        // Add shard information if available
+        if (config.shard) {
+            this.runMetadata.shardInfo = {
+                current: config.shard.current,
+                total: config.shard.total
+            };
+        }
+        // Send run start event to API
+        await this.sendToApi({
+            type: 'runStart',
+            runId: this.runId,
+            timestamp: new Date().toISOString(),
+            metadata: this.runMetadata
+        });
+    }
+    async onTestBegin(test, result) {
+        // Log which test is starting
+        console.log(`\n▶️  Running test: ${test.title}`);
+        const specPath = test.location.file;
+        const specKey = `${specPath}-${test.parent.title}`;
+        // Create or update spec data
+        if (!this.specMap.has(specKey)) {
+            const extractedTags = this.extractTags(test);
+            const specData = {
+                filePath: path.relative(process.cwd(), specPath),
+                testSuiteName: test.parent.title,
+                startTime: new Date().toISOString(),
+                status: 'running'
+            };
+            if (extractedTags.length > 0) {
+                specData.tags = extractedTags;
+            }
+            this.specMap.set(specKey, specData);
+            // Send spec start event to API
+            await this.sendToApi({
+                type: 'specStart',
+                runId: this.runId,
+                timestamp: new Date().toISOString(),
+                spec: specData
+            });
+        }
+        const testId = this.getTestId(test);
+        // Only send testStart event on first attempt (retry 0)
+        if (result.retry === 0) {
+            // Create test data
+            const testData = {
+                id: testId,
+                name: test.title,
+                status: 'running',
+                originalStatus: 'running',
+                duration: 0,
+                startTime: new Date().toISOString(),
+                endTime: '',
+                errorMessages: [],
+                errors: [],
+                retryAttempts: test.retries,
+                currentRetry: result.retry,
+                annotations: test.annotations.map((ann) => ({
+                    type: ann.type,
+                    description: ann.description
+                })),
+                projectName: test.parent.project()?.name || 'default',
+                workerIndex: result.workerIndex,
+                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
+            await this.sendToApi({
+                type: 'testStart',
+                runId: this.runId,
+                timestamp: new Date().toISOString(),
+                test: testData
+            });
+        }
+        else {
+            // For retries, just update the existing test data
+            const existingTestData = this.testMap.get(testId);
+            if (existingTestData) {
+                existingTestData.currentRetry = result.retry;
+            }
+        }
+    }
+    async onTestEnd(test, result) {
+        const testId = this.getTestId(test);
+        let testData = this.testMap.get(testId);
+        console.log(`[TestLens] onTestEnd called for test: ${test.title}, status: ${result.status}, testData exists: ${!!testData}`);
+        // For skipped tests, onTestBegin might not be called, so we need to create the test data here
+        if (!testData) {
+            console.log(`[TestLens] Creating test data for skipped/uncreated test: ${test.title}`);
+            // Create spec data if not exists (skipped tests might not have spec data either)
+            const specPath = test.location.file;
+            const specKey = `${specPath}-${test.parent.title}`;
+            if (!this.specMap.has(specKey)) {
+                const extractedTags = this.extractTags(test);
+                const specData = {
+                    filePath: path.relative(process.cwd(), specPath),
+                    testSuiteName: test.parent.title,
+                    startTime: new Date().toISOString(),
+                    status: 'skipped'
+                };
+                if (extractedTags.length > 0) {
+                    specData.tags = extractedTags;
+                }
+                this.specMap.set(specKey, specData);
+                // Send spec start event to API
+                await this.sendToApi({
+                    type: 'specStart',
+                    runId: this.runId,
+                    timestamp: new Date().toISOString(),
+                    spec: specData
+                });
+            }
+            // Create test data for skipped test
+            testData = {
+                id: testId,
+                name: test.title,
+                status: 'skipped',
+                originalStatus: 'skipped',
+                duration: 0,
+                startTime: new Date().toISOString(),
+                endTime: new Date().toISOString(),
+                errorMessages: [],
+                errors: [],
+                retryAttempts: test.retries,
+                currentRetry: 0,
+                annotations: test.annotations.map((ann) => ({
+                    type: ann.type,
+                    description: ann.description
+                })),
+                projectName: test.parent.project()?.name || 'default',
+                workerIndex: result.workerIndex,
+                parallelIndex: result.parallelIndex,
+                location: {
+                    file: path.relative(process.cwd(), test.location.file),
+                    line: test.location.line,
+                    column: test.location.column
+                }
+            };
+            this.testMap.set(testId, testData);
+            // Send test start event first (so the test gets created in DB)
+            await this.sendToApi({
+                type: 'testStart',
+                runId: this.runId,
+                timestamp: new Date().toISOString(),
+                test: testData
+            });
+        }
+        if (testData) {
+            // Update test data with latest result
+            testData.originalStatus = result.status;
+            testData.status = this.normalizeTestStatus(result.status);
+            testData.duration = result.duration;
+            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;
+            if (isFinalAttempt) {
+                console.log(`[TestLens] Sending testEnd - testId: ${testData.id}, status: ${testData.status}, originalStatus: ${testData.originalStatus}`);
+                // Send test end event to API
+                await this.sendToApi({
+                    type: 'testEnd',
+                    runId: this.runId,
+                    timestamp: new Date().toISOString(),
+                    test: testData
+                });
+                // Handle artifacts
+                if (this.config.enableArtifacts) {
+                    await this.processArtifacts(testId, result);
+                }
+            }
+        }
+        // Update spec status
+        const specPath = test.location.file;
+        const specKey = `${specPath}-${test.parent.title}`;
+        const specData = this.specMap.get(specKey);
+        if (specData) {
+            const normalizedStatus = this.normalizeTestStatus(result.status);
+            if (normalizedStatus === 'failed' && specData.status !== 'failed') {
+                specData.status = 'failed';
+            }
+            else if (result.status === 'skipped' && specData.status === 'passed') {
+                specData.status = 'skipped';
+            }
+            // Check if all tests in spec are complete
+            const remainingTests = test.parent.tests.filter((t) => {
+                const tId = this.getTestId(t);
+                const tData = this.testMap.get(tId);
+                return !tData || !tData.endTime;
+            });
+            if (remainingTests.length === 0) {
+                // Aggregate tags from all tests in this spec
+                const allTags = new Set();
+                test.parent.tests.forEach((t) => {
+                    const tags = this.extractTags(t);
+                    tags.forEach(tag => allTags.add(tag));
+                });
+                const aggregatedTags = Array.from(allTags);
+                // Only update tags if we have any
+                if (aggregatedTags.length > 0) {
+                    specData.tags = aggregatedTags;
+                }
+                specData.endTime = new Date().toISOString();
+                // Send spec end event to API
+                await this.sendToApi({
+                    type: 'specEnd',
+                    runId: this.runId,
+                    timestamp: new Date().toISOString(),
+                    spec: specData
+                });
+                // Send spec code blocks to API
+                await this.sendSpecCodeBlocks(specPath);
+            }
+        }
+    }
+    async onEnd(result) {
+        this.runMetadata.endTime = new Date().toISOString();
+        this.runMetadata.duration = Date.now() - new Date(this.runMetadata.startTime).getTime();
+        // 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;
+        const normalizedRunStatus = this.normalizeRunStatus(result.status, hasTimeouts);
+        // Send run end event to API
+        await this.sendToApi({
+            type: 'runEnd',
+            runId: this.runId,
+            timestamp: new Date().toISOString(),
+            metadata: {
+                ...this.runMetadata,
+                totalTests,
+                passedTests,
+                failedTests, // Already includes timedOut tests (normalized to 'failed')
+                skippedTests,
+                timedOutTests, // For informational purposes
+                status: normalizedRunStatus
+            }
+        });
+        // Show Build Name if provided, otherwise show Run ID
+        if (this.runMetadata.testlensBuildName) {
+            console.log(`📊 TestLens Report completed - Build: ${this.runMetadata.testlensBuildName}`);
+            console.log(`   Run ID: ${this.runId}`);
+        }
+        else {
+            console.log(`📊 TestLens Report completed - Run ID: ${this.runId}`);
+        }
+        console.log(`🎯 Results: ${passedTests} passed, ${failedTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
+    }
+    async sendToApi(payload) {
+        // Skip sending if run creation already failed
+        if (this.runCreationFailed && payload.type !== 'runStart') {
+            return;
+        }
+        try {
+            const response = await this.axiosInstance.post('', payload, {
+                headers: {
+                    'X-API-Key': this.config.apiKey
+                }
+            });
+            if (this.config.enableRealTimeStream) {
+                console.log(`✅ Sent ${payload.type} event to TestLens (HTTP ${response.status})`);
+            }
+        }
+        catch (error) {
+            const errorData = error?.response?.data;
+            const status = error?.response?.status;
+            // Check for limit exceeded (403)
+            if (status === 403 && errorData?.error === 'limit_exceeded') {
+                // Set flag to skip subsequent events
+                if (payload.type === 'runStart' && errorData?.limit_type === 'test_runs') {
+                    this.runCreationFailed = true;
+                }
+                console.error('\n' + '='.repeat(80));
+                if (errorData?.limit_type === 'test_cases') {
+                    console.error('❌ TESTLENS ERROR: Test Cases Limit Reached');
+                }
+                else if (errorData?.limit_type === 'test_runs') {
+                    console.error('❌ TESTLENS ERROR: Test Runs Limit Reached');
+                }
+                else {
+                    console.error('❌ TESTLENS ERROR: Plan Limit Reached');
+                }
+                console.error('='.repeat(80));
+                console.error('');
+                console.error(errorData?.message || 'You have reached your plan limit.');
+                console.error('');
+                console.error(`Current usage: ${errorData?.current_usage || 'N/A'} / ${errorData?.limit || 'N/A'}`);
+                console.error('');
+                console.error('To continue, please upgrade your plan.');
+                console.error('Contact: support@alternative-path.com');
+                console.error('');
+                console.error('='.repeat(80));
+                console.error('');
+                return; // Don't log the full error object for limit errors
+            }
+            // Check for trial expiration, subscription errors, or limit errors (401)
+            if (status === 401) {
+                if (errorData?.error === 'trial_expired' || errorData?.error === 'subscription_inactive' ||
+                    errorData?.error === 'test_cases_limit_reached' || errorData?.error === 'test_runs_limit_reached') {
+                    console.error('\n' + '='.repeat(80));
+                    if (errorData?.error === 'test_cases_limit_reached') {
+                        console.error('❌ TESTLENS ERROR: Test Cases Limit Reached');
+                    }
+                    else if (errorData?.error === 'test_runs_limit_reached') {
+                        console.error('❌ TESTLENS ERROR: Test Runs Limit Reached');
+                    }
+                    else {
+                        console.error('❌ TESTLENS ERROR: Your trial plan has ended');
+                    }
+                    console.error('='.repeat(80));
+                    console.error('');
+                    console.error(errorData?.message || 'Your trial period has expired.');
+                    console.error('');
+                    console.error('To continue using TestLens, please upgrade to Enterprise plan.');
+                    console.error('Contact: ' + (errorData?.contactEmail || 'support@alternative-path.com'));
+                    console.error('');
+                    if (errorData?.trial_end_date) {
+                        console.error(`Trial ended: ${new Date(errorData.trial_end_date).toLocaleDateString()}`);
+                        console.error('');
+                    }
+                    console.error('='.repeat(80));
+                    console.error('');
+                }
+                else {
+                    console.error(`❌ Authentication failed: ${errorData?.error || 'Invalid API key'}`);
+                }
+            }
+            else if (status !== 403) {
+                // Log other errors (but not 403 which we handled above)
+                console.error(`❌ Failed to send ${payload.type} event to TestLens:`, {
+                    message: error?.message || 'Unknown error',
+                    status: status,
+                    statusText: error?.response?.statusText,
+                    data: errorData,
+                    code: error?.code,
+                    url: error?.config?.url,
+                    method: error?.config?.method
+                });
+            }
+            // Don't throw error to avoid breaking test execution
+        }
+    }
+    async processArtifacts(testId, result) {
+        // Skip artifact processing if run creation failed
+        if (this.runCreationFailed) {
+            return;
+        }
+        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, 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: fileName,
+                        contentType: attachment.contentType,
+                        fileSize: this.getFileSize(attachment.path),
+                        storageType: 's3',
+                        s3Key: s3Data.key,
+                        s3Url: s3Data.url
+                    };
+                    // Send artifact data to API
+                    await this.sendToApi({
+                        type: 'artifact',
+                        runId: this.runId,
+                        timestamp: new Date().toISOString(),
+                        artifact: artifactData
+                    });
+                    console.log(`📎 Processed artifact: ${fileName} (uploaded to S3)`);
+                }
+                catch (error) {
+                    console.error(`❌ Failed to process artifact ${attachment.name}:`, error.message);
+                }
+            }
+        }
+    }
+    async sendSpecCodeBlocks(specPath) {
+        try {
+            // Extract code blocks using built-in parser
+            const testBlocks = this.extractTestBlocks(specPath);
+            // Transform blocks to match backend API expectations
+            const codeBlocks = testBlocks.map(block => ({
+                type: block.type, // 'test' or 'describe'
+                name: block.name, // test/describe name
+                content: block.content, // full code content
+                summary: null, // optional
+                describe: block.describe // parent describe block name
+            }));
+            // Send to dedicated spec code blocks API endpoint
+            const baseUrl = this.config.apiEndpoint.replace('/webhook/playwright', '');
+            const specEndpoint = `${baseUrl}/webhook/playwright/spec-code-blocks`;
+            await this.axiosInstance.post(specEndpoint, {
+                filePath: path.relative(process.cwd(), specPath),
+                codeBlocks,
+                testSuiteName: path.basename(specPath).replace(/\.(spec|test)\.(js|ts)$/, '')
+            });
+            console.log(`📝 Sent ${codeBlocks.length} code blocks for: ${path.basename(specPath)}`);
+        }
+        catch (error) {
+            const errorData = error?.response?.data;
+            // Handle duplicate spec code blocks gracefully (when re-running tests)
+            if (errorData?.error && errorData.error.includes('duplicate key value violates unique constraint')) {
+                console.log(`ℹ️  Spec code blocks already exist for: ${path.basename(specPath)} (skipped)`);
+                return;
+            }
+            console.error('Failed to send spec code blocks:', errorData || error?.message || 'Unknown error');
+        }
+    }
+    extractTestBlocks(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const blocks = [];
+            const lines = content.split('\n');
+            let currentDescribe = null;
+            let braceCount = 0;
+            let inBlock = false;
+            let blockStart = -1;
+            let blockType = 'test';
+            let blockName = '';
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmedLine = line.trim();
+                // Check for describe blocks
+                const describeMatch = trimmedLine.match(/describe\s*\(\s*['"`]([^'"`]+)['"`]/);
+                if (describeMatch) {
+                    currentDescribe = describeMatch[1];
+                }
+                // Check for test blocks
+                const testMatch = trimmedLine.match(/test\s*\(\s*['"`]([^'"`]+)['"`]/);
+                if (testMatch && !inBlock) {
+                    blockType = 'test';
+                    blockName = testMatch[1];
+                    blockStart = i;
+                    braceCount = 0;
+                    inBlock = true;
+                }
+                // Count braces when in a block
+                if (inBlock) {
+                    for (const char of line) {
+                        if (char === '{')
+                            braceCount++;
+                        if (char === '}')
+                            braceCount--;
+                        if (braceCount === 0 && blockStart !== -1 && i > blockStart) {
+                            // End of block found
+                            const blockContent = lines.slice(blockStart, i + 1).join('\n');
+                            blocks.push({
+                                type: blockType,
+                                name: blockName,
+                                content: blockContent,
+                                describe: currentDescribe || undefined,
+                                startLine: blockStart + 1,
+                                endLine: i + 1
+                            });
+                            inBlock = false;
+                            blockStart = -1;
+                            break;
+                        }
+                    }
+                }
+            }
+            return blocks;
+        }
+        catch (error) {
+            console.error(`Failed to extract test blocks from ${filePath}:`, error.message);
+            return [];
+        }
+    }
+    async collectGitInfo() {
+        try {
+            const branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+            const commit = (0, child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+            const shortCommit = commit.substring(0, 7);
+            const author = (0, child_process_1.execSync)('git log -1 --pretty=format:"%an"', { encoding: 'utf-8' }).trim();
+            const commitMessage = (0, child_process_1.execSync)('git log -1 --pretty=format:"%s"', { encoding: 'utf-8' }).trim();
+            const commitTimestamp = (0, child_process_1.execSync)('git log -1 --pretty=format:"%ci"', { encoding: 'utf-8' }).trim();
+            let remoteName = 'origin';
+            let remoteUrl = '';
+            try {
+                const remotes = (0, child_process_1.execSync)('git remote', { encoding: 'utf-8' }).trim();
+                if (remotes) {
+                    remoteName = remotes.split('\n')[0] || 'origin';
+                    remoteUrl = (0, child_process_1.execSync)(`git remote get-url ${remoteName}`, { encoding: 'utf-8' }).trim();
+                }
+            }
+            catch (e) {
+                // Remote info is optional - handle gracefully
+                console.log('ℹ️  No git remote configured, skipping remote info');
+            }
+            const isDirty = (0, child_process_1.execSync)('git status --porcelain', { encoding: 'utf-8' }).trim().length > 0;
+            return {
+                branch,
+                commit,
+                shortCommit,
+                author,
+                message: commitMessage,
+                timestamp: commitTimestamp,
+                isDirty,
+                remoteName,
+                remoteUrl
+            };
+        }
+        catch (error) {
+            // Silently skip git information if not in a git repository
+            return null;
+        }
+    }
+    getArtifactType(name) {
+        if (name.includes('screenshot'))
+            return 'screenshot';
+        if (name.includes('video'))
+            return 'video';
+        if (name.includes('trace'))
+            return 'trace';
+        return 'attachment';
+    }
+    extractTags(test) {
+        const tags = [];
+        // Playwright stores tags in the _tags property
+        const testTags = test._tags;
+        if (testTags && Array.isArray(testTags)) {
+            tags.push(...testTags);
+        }
+        // Also get tags from parent suites by walking up the tree
+        let currentSuite = test.parent;
+        while (currentSuite) {
+            const suiteTags = currentSuite._tags;
+            if (suiteTags && Array.isArray(suiteTags)) {
+                tags.push(...suiteTags);
+            }
+            currentSuite = currentSuite.parent;
+        }
+        // Also extract @tags from test title for backward compatibility
+        const tagMatches = test.title.match(/@[\w-]+/g);
+        if (tagMatches) {
+            tags.push(...tagMatches);
+        }
+        // Add testlensBuildTag from custom metadata if present
+        if (this.config.customMetadata?.testlensBuildTag) {
+            tags.push(`@${this.config.customMetadata.testlensBuildTag}`);
+        }
+        // Remove duplicates and return
+        return [...new Set(tags)];
+    }
+    getTestId(test) {
+        const cleanTitle = test.title.replace(/@[\w-]+/g, '').trim();
+        // Normalize path separators to forward slashes for cross-platform consistency
+        const normalizedFile = test.location.file.replace(/\\/g, '/');
+        return `${normalizedFile}:${test.location.line}:${cleanTitle}`;
+    }
+    async uploadArtifactToS3(filePath, testId, fileName) {
+        try {
+            // Check file size first
+            const fileSize = this.getFileSize(filePath);
+            const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);
+            console.log(`📤 Uploading ${fileName} (${fileSizeMB}MB) directly to S3...`);
+            const baseUrl = this.config.apiEndpoint.replace('/api/v1/webhook/playwright', '');
+            // Step 1: Request pre-signed URL from server
+            const presignedUrlEndpoint = `${baseUrl}/api/v1/artifacts/public/presigned-url`;
+            const presignedResponse = await this.axiosInstance.post(presignedUrlEndpoint, {
+                apiKey: this.config.apiKey,
+                testRunId: this.runId,
+                testId: testId,
+                fileName: fileName,
+                fileType: await this.getContentType(fileName),
+                fileSize: fileSize,
+                artifactType: this.getArtifactType(fileName)
+            }, {
+                timeout: 10000 // Quick timeout for metadata request
+            });
+            if (!presignedResponse.data.success) {
+                throw new Error(`Failed to get presigned URL: ${presignedResponse.data.error || 'Unknown error'}`);
+            }
+            const { uploadUrl, s3Key, metadata } = presignedResponse.data;
+            // Step 2: Upload directly to S3 using presigned URL
+            console.log(`⬆️  Uploading ${fileName} directly to S3 (bypass server)...`);
+            const fileBuffer = fs.readFileSync(filePath);
+            // IMPORTANT: When using presigned URLs, we MUST include exactly the headers that were signed
+            // The backend signs with ServerSideEncryption:'AES256', so we must send that header
+            // AWS presigned URLs are very strict about header matching
+            const uploadResponse = await axios_1.default.put(uploadUrl, fileBuffer, {
+                headers: {
+                    'x-amz-server-side-encryption': 'AES256'
+                },
+                maxContentLength: Infinity,
+                maxBodyLength: Infinity,
+                timeout: Math.max(600000, Math.ceil(fileSize / (1024 * 1024)) * 10000), // 10s per MB, min 10 minutes - increased for large trace files
+                // Don't use custom HTTPS agent for S3 uploads
+                httpsAgent: undefined
+            });
+            if (uploadResponse.status !== 200) {
+                throw new Error(`S3 upload failed with status ${uploadResponse.status}`);
+            }
+            console.log(`✅ S3 direct upload completed for ${fileName}`);
+            // Step 3: Confirm upload with server to save metadata
+            const confirmEndpoint = `${baseUrl}/api/v1/artifacts/public/confirm-upload`;
+            const confirmResponse = await this.axiosInstance.post(confirmEndpoint, {
+                apiKey: this.config.apiKey,
+                testRunId: this.runId,
+                testId: testId,
+                s3Key: s3Key,
+                fileName: fileName,
+                fileType: await this.getContentType(fileName),
+                fileSize: fileSize,
+                artifactType: this.getArtifactType(fileName)
+            }, {
+                timeout: 10000
+            });
+            if (confirmResponse.status === 201 && confirmResponse.data.success) {
+                const artifact = confirmResponse.data.artifact;
+                console.log(`✅ Upload confirmed and saved to database`);
+                return {
+                    key: s3Key,
+                    url: artifact.s3Url,
+                    presignedUrl: artifact.presignedUrl,
+                    fileSize: artifact.fileSize,
+                    contentType: artifact.contentType
+                };
+            }
+            else {
+                throw new Error(`Upload confirmation failed: ${confirmResponse.data.error || 'Unknown error'}`);
+            }
+        }
+        catch (error) {
+            // Check for trial expiration, subscription errors, or limit errors
+            if (error?.response?.status === 401) {
+                const errorData = error?.response?.data;
+                if (errorData?.error === 'trial_expired' || errorData?.error === 'subscription_inactive' ||
+                    errorData?.error === 'test_cases_limit_reached' || errorData?.error === 'test_runs_limit_reached') {
+                    console.error('\\n' + '='.repeat(80));
+                    if (errorData?.error === 'test_cases_limit_reached') {
+                        console.error('❌ TESTLENS ERROR: Test Cases Limit Reached');
+                    }
+                    else if (errorData?.error === 'test_runs_limit_reached') {
+                        console.error('❌ TESTLENS ERROR: Test Runs Limit Reached');
+                    }
+                    else {
+                        console.error('❌ TESTLENS ERROR: Your trial plan has ended');
+                    }
+                    console.error('='.repeat(80));
+                    console.error('');
+                    console.error(errorData?.message || 'Your trial period has expired.');
+                    console.error('');
+                    console.error('To continue using TestLens, please upgrade to Enterprise plan.');
+                    console.error('Contact: ' + (errorData?.contactEmail || 'support@alternative-path.com'));
+                    console.error('');
+                    if (errorData?.trial_end_date) {
+                        console.error(`Trial ended: ${new Date(errorData.trial_end_date).toLocaleDateString()}`);
+                        console.error('');
+                    }
+                    console.error('='.repeat(80));
+                    console.error('');
+                    return null;
+                }
+            }
+            // Better error messages for common issues
+            let errorMsg = error.message;
+            if (error.code === 'ECONNABORTED' && error.message.includes('timeout')) {
+                errorMsg = `Upload timeout - file may be too large or connection is slow`;
+            }
+            else if (error.response?.status === 413) {
+                errorMsg = `File too large (413) - server rejected the upload`;
+            }
+            else if (error.response?.status === 400) {
+                errorMsg = `Bad request (400) - ${error.response.data?.error || 'check file format'}`;
+            }
+            else if (error.response?.status === 403) {
+                errorMsg = `Access denied (403) - presigned URL may have expired`;
+            }
+            console.error(`❌ Failed to upload ${fileName} to S3:`, errorMsg);
+            if (error.response?.data) {
+                console.error('Error details:', error.response.data);
+            }
+            // Don't throw, just return null to continue with other artifacts
+            return null;
+        }
+    }
+    async getContentType(fileName) {
+        const ext = path.extname(fileName).toLowerCase();
+        try {
+            const mime = await getMime();
+            // Try different ways to access getType method
+            const getType = mime.getType || mime.default?.getType;
+            if (typeof getType === 'function') {
+                const mimeType = getType.call(mime, ext) || getType.call(mime.default, ext);
+                return mimeType || 'application/octet-stream';
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to get MIME type for ${fileName}:`, error.message);
+        }
+        // Fallback to basic content type mapping
+        const contentTypes = {
+            '.mp4': 'video/mp4',
+            '.webm': 'video/webm',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.json': 'application/json',
+            '.txt': 'text/plain',
+            '.html': 'text/html',
+            '.xml': 'application/xml',
+            '.zip': 'application/zip',
+            '.pdf': 'application/pdf'
+        };
+        return contentTypes[ext] || 'application/octet-stream';
+    }
+    generateS3Key(runId, testId, fileName) {
+        const date = new Date().toISOString().slice(0, 10);
+        const safeTestId = this.sanitizeForS3(testId);
+        const safeFileName = this.sanitizeForS3(fileName);
+        const ext = path.extname(fileName);
+        const baseName = path.basename(fileName, ext);
+        return `test-artifacts/${date}/${runId}/${safeTestId}/${safeFileName}${ext}`;
+    }
+    sanitizeForS3(value) {
+        return value
+            .replace(/[\/:*?"<>|]/g, '-')
+            .replace(/[-\u001f\u007f]/g, '-')
+            .replace(/[^-~]/g, '-')
+            .replace(/\s+/g, '-')
+            .replace(/[_]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+    }
+    getFileSize(filePath) {
+        try {
+            const stats = fs.statSync(filePath);
+            return stats.size;
+        }
+        catch (error) {
+            console.warn(`Could not get file size for ${filePath}:`, error.message);
+            return 0;
+        }
+    }
+}
+exports.TestLensReporter = TestLensReporter;
+exports.default = TestLensReporter;