testlens-playwright-reporter 0.1.0

package/index.ts

@@ -0,0 +1,814 @@
+import { randomUUID } from 'crypto';
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as https from 'https';
+import axios, { AxiosInstance } from 'axios';
+import { Reporter, TestCase, TestResult, FullConfig, Suite } from '@playwright/test/reporter';
+import { execSync } from 'child_process';
+import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import * as mime from 'mime';
+
+// Embedded configuration from .env file (generated during build)
+const EMBEDDED_CONFIG = {
+  "AWS_ACCESS_KEY_ID": "AKIA5QK76YZKWA2P5V4E",
+  "AWS_SECRET_ACCESS_KEY": "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",
+  "AWS_REGION": "eu-north-1",
+  "S3_BUCKET_NAME": "testlenss3",
+  "S3_ACL": "private",
+  "TEST_API_ENDPOINT": "https://testlens.qa-path.com/api/v1/webhook/playwright"
+};
+
+export interface TestLensReporterConfig {
+  /** TestLens API endpoint URL */
+  apiEndpoint?: string;
+  /** API key for authentication - required, must be provided in config */
+  apiKey: string;
+  /** Enable real-time streaming of test events */
+  enableRealTimeStream?: boolean;
+  /** Enable Git information collection */
+  enableGitInfo?: boolean;
+  /** Enable artifact processing */
+  enableArtifacts?: boolean;
+  /** Enable S3 upload for artifacts */
+  enableS3Upload?: boolean;
+  /** Batch size for API requests */
+  batchSize?: number;
+  /** Flush interval in milliseconds */
+  flushInterval?: number;
+  /** Number of retry attempts for failed API calls */
+  retryAttempts?: number;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+  /** SSL certificate validation - set to false to disable SSL verification */
+  rejectUnauthorized?: boolean;
+  /** Alternative SSL option - set to true to ignore SSL certificate errors */
+  ignoreSslErrors?: boolean;
+}
+
+export interface TestLensReporterOptions {
+  /** TestLens API endpoint URL */
+  apiEndpoint?: string;
+  /** API key for authentication - required, must be provided in config */
+  apiKey: string;
+  /** Enable real-time streaming of test events */
+  enableRealTimeStream?: boolean;
+  /** Enable Git information collection */
+  enableGitInfo?: boolean;
+  /** Enable artifact processing */
+  enableArtifacts?: boolean;
+  /** Enable S3 upload for artifacts */
+  enableS3Upload?: boolean;
+  /** Batch size for API requests */
+  batchSize?: number;
+  /** Flush interval in milliseconds */
+  flushInterval?: number;
+  /** Number of retry attempts for failed API calls */
+  retryAttempts?: number;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+  /** SSL certificate validation - set to false to disable SSL verification */
+  rejectUnauthorized?: boolean;
+  /** Alternative SSL option - set to true to ignore SSL certificate errors */
+  ignoreSslErrors?: boolean;
+}
+
+export interface GitInfo {
+  branch: string;
+  commit: string;
+  shortCommit: string;
+  author: string;
+  commitMessage: string;
+  commitTimestamp: string;
+  isDirty: boolean;
+  remoteName: string;
+  remoteUrl: string;
+}
+
+export interface CodeBlock {
+  type: 'test' | 'describe';
+  name: string;
+  content: string;
+  summary?: string;
+  describe?: string;
+  startLine?: number;
+  endLine?: number;
+}
+
+export interface RunMetadata {
+  id: string;
+  startTime: string;
+  endTime?: string;
+  duration?: number;
+  environment: string;
+  browser: string;
+  os: string;
+  playwrightVersion: string;
+  nodeVersion: string;
+  gitInfo?: GitInfo | null;
+  shardInfo?: {
+    current: number;
+    total: number;
+  };
+  totalTests?: number;
+  passedTests?: number;
+  failedTests?: number;
+  skippedTests?: number;
+  status?: string;
+}
+
+export interface TestData {
+  id: string;
+  name: string;
+  status: string;
+  originalStatus?: string; // Preserve original Playwright status
+  duration: number;
+  startTime: string;
+  endTime: string;
+  errorMessages: string[];
+  retryAttempts: number;
+  currentRetry: number;
+  annotations: Array<{ type: string; description?: string }>;
+  projectName: string;
+  workerIndex?: number;
+  parallelIndex?: number;
+}
+
+export interface SpecData {
+  filePath: string;
+  testSuiteName: string;
+  tags: string[];
+  startTime: string;
+  endTime?: string;
+  status: string;
+}
+
+export class TestLensReporter implements Reporter {
+  private config: Required<TestLensReporterConfig>;
+  private axiosInstance: AxiosInstance;
+  private s3Client: S3Client | null;
+  private s3Enabled: boolean;
+  private runId: string;
+  private runMetadata: RunMetadata;
+  private specMap: Map<string, SpecData>;
+  private testMap: Map<string, TestData>;
+
+  constructor(options: TestLensReporterOptions) {
+    this.config = {
+      apiEndpoint: EMBEDDED_CONFIG.TEST_API_ENDPOINT || options.apiEndpoint || '',
+      apiKey: options.apiKey, // API key must come from config file
+      enableRealTimeStream: options.enableRealTimeStream !== false,
+      enableGitInfo: options.enableGitInfo !== false,
+      enableArtifacts: options.enableArtifacts !== false,
+      enableS3Upload: options.enableS3Upload !== false,
+      batchSize: options.batchSize || 10,
+      flushInterval: options.flushInterval || 5000,
+      retryAttempts: options.retryAttempts || 3,
+      timeout: options.timeout || 30000,
+      rejectUnauthorized: options.rejectUnauthorized !== false, // Default to true for security
+      ignoreSslErrors: options.ignoreSslErrors === true // Explicit opt-in to ignore SSL errors
+    } as Required<TestLensReporterConfig>;
+
+    if (!this.config.apiEndpoint) {
+      throw new Error('TEST_API_ENDPOINT is required for TestLensReporter. Set it in environment variable or pass as option.');
+    }
+
+    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;
+      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.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
+      httpsAgent: new https.Agent({
+        rejectUnauthorized: rejectUnauthorized,
+        // Additional SSL options for better compatibility
+        secureProtocol: 'TLSv1_2_method',
+        ciphers: 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA384'
+      })
+    });
+
+    // Add retry interceptor
+    this.axiosInstance.interceptors.response.use(
+      (response) => response,
+      async (error: any) => {
+        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);
+      }
+    );
+
+    // Initialize S3 client if S3 upload is enabled
+    this.s3Client = null;
+    this.s3Enabled = this.config.enableS3Upload && !!EMBEDDED_CONFIG.S3_BUCKET_NAME;
+    
+    if (this.s3Enabled) {
+      try {
+        const s3Config: any = {
+          region: EMBEDDED_CONFIG.AWS_REGION || 'us-east-1',
+          maxAttempts: 3
+        };
+        
+        if (EMBEDDED_CONFIG.AWS_ACCESS_KEY_ID && EMBEDDED_CONFIG.AWS_SECRET_ACCESS_KEY) {
+          s3Config.credentials = {
+            accessKeyId: EMBEDDED_CONFIG.AWS_ACCESS_KEY_ID,
+            secretAccessKey: EMBEDDED_CONFIG.AWS_SECRET_ACCESS_KEY
+          };
+        }
+        
+        this.s3Client = new S3Client(s3Config);
+        console.log('✅ S3 client initialized for artifact uploads');
+      } catch (error) {
+        console.error('❌ Failed to initialize S3 client:', (error as Error).message);
+        this.s3Enabled = false;
+      }
+    }
+
+    this.runId = randomUUID();
+    this.runMetadata = this.initializeRunMetadata();
+    this.specMap = new Map<string, SpecData>();
+    this.testMap = new Map<string, TestData>();
+  }
+
+  private initializeRunMetadata(): RunMetadata {
+    return {
+      id: this.runId,
+      startTime: new Date().toISOString(),
+      environment: 'production',
+      browser: 'multiple',
+      os: `${os.type()} ${os.release()}`,
+      playwrightVersion: this.getPlaywrightVersion(),
+      nodeVersion: process.version
+    };
+  }
+
+  private getPlaywrightVersion(): string {
+    try {
+      const playwrightPackage = require('@playwright/test/package.json');
+      return playwrightPackage.version;
+    } catch (error) {
+      return 'unknown';
+    }
+  }
+
+  private normalizeTestStatus(status: string): string {
+    // Treat timeout as failed for consistency with analytics
+    if (status === 'timedOut') {
+      return 'failed';
+    }
+    return status;
+  }
+
+  private normalizeRunStatus(status: string, hasTimeouts: boolean): string {
+    // 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: FullConfig, suite: Suite): Promise<void> {
+    console.log(`🚀 TestLens Reporter starting - Run ID: ${this.runId}`);
+    
+    // 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: TestCase, result: TestResult): Promise<void> {
+    const specPath = test.location.file;
+    const specKey = `${specPath}-${test.parent.title}`;
+
+    // Create or update spec data
+    if (!this.specMap.has(specKey)) {
+      const specData: SpecData = {
+        filePath: path.relative(process.cwd(), specPath),
+        testSuiteName: test.parent.title,
+        tags: this.extractTags(test),
+        startTime: new Date().toISOString(),
+        status: 'passed'
+      };
+      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
+    const testData: TestData = {
+      id: this.getTestId(test),
+      name: test.title,
+      status: 'passed',
+      originalStatus: 'passed',
+      duration: 0,
+      startTime: new Date().toISOString(),
+      endTime: '',
+      errorMessages: [],
+      retryAttempts: test.retries,
+      currentRetry: result.retry,
+      annotations: test.annotations.map((ann: any) => ({
+        type: ann.type,
+        description: ann.description
+      })),
+      projectName: test.parent.project()?.name || 'default',
+      workerIndex: result.workerIndex,
+      parallelIndex: result.parallelIndex
+    };
+
+    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
+    });
+  }
+
+  async onTestEnd(test: TestCase, result: TestResult): Promise<void> {
+    const testId = this.getTestId(test);
+    const testData = this.testMap.get(testId);
+
+    if (testData) {
+      // Preserve original status for detailed reporting, but normalize for consistency
+      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: any) => error.message || error.toString());
+
+      // 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: any) => {
+        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: { status: string }): Promise<void> {
+    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;
+    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;
+    const timedOutTests = Array.from(this.testMap.values()).filter(t => t.status === '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: failedTests + timedOutTests, // Include timeouts in failed count
+        skippedTests,
+        timedOutTests,
+        status: normalizedRunStatus
+      }
+    });
+
+    console.log(`📊 TestLens Report completed - Run ID: ${this.runId}`);
+    console.log(`🎯 Results: ${passedTests} passed, ${failedTests + timedOutTests} failed (${timedOutTests} timeouts), ${skippedTests} skipped`);
+  }
+
+  private async sendToApi(payload: any): Promise<void> {
+    try {
+      const response = await this.axiosInstance.post('', payload);
+      if (this.config.enableRealTimeStream) {
+        console.log(`✅ Sent ${payload.type} event to TestLens`);
+      }
+    } catch (error: any) {
+      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
+    }
+  }
+
+  private async processArtifacts(testId: string, result: TestResult): Promise<void> {
+    const attachments = result.attachments;
+    
+    for (const attachment of attachments) {
+      if (attachment.path) {
+        try {
+          let s3Data: { key: string; url: string; presignedUrl: string; fileSize: number; contentType: string } | null = null;
+          
+          // Upload to S3 if enabled
+          if (this.s3Enabled && this.s3Client) {
+            s3Data = await this.uploadArtifactToS3(attachment.path, testId, attachment.name);
+          }
+          
+          const artifactData = {
+            testId,
+            type: this.getArtifactType(attachment.name),
+            path: attachment.path,
+            name: attachment.name,
+            contentType: attachment.contentType,
+            fileSize: s3Data ? s3Data.fileSize : this.getFileSize(attachment.path),
+            ...(s3Data && {
+              s3Key: s3Data.key,
+              s3Url: s3Data.url,
+              presignedUrl: s3Data.presignedUrl,
+              storageType: 's3'
+            })
+          };
+
+          // Send artifact data to API
+          await this.sendToApi({
+            type: 'artifact',
+            runId: this.runId,
+            timestamp: new Date().toISOString(),
+            artifact: artifactData
+          });
+          
+          console.log(`📎 Processed artifact: ${attachment.name}${s3Data ? ' (uploaded to S3)' : ''}`);
+        } catch (error) {
+          console.error(`❌ Failed to process artifact ${attachment.name}:`, (error as Error).message);
+        }
+      }
+    }
+  }
+
+  private async sendSpecCodeBlocks(specPath: string): Promise<void> {
+    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: any) {
+      console.error('Failed to send spec code blocks:', error?.response?.data || error?.message || 'Unknown error');
+    }
+  }
+
+  private extractTestBlocks(filePath: string): CodeBlock[] {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const blocks: CodeBlock[] = [];
+      const lines = content.split('\n');
+      
+      let currentDescribe: string | null = null;
+      let braceCount = 0;
+      let inBlock = false;
+      let blockStart = -1;
+      let blockType: 'test' | 'describe' = '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: any) {
+      console.error(`Failed to extract test blocks from ${filePath}:`, error.message);
+      return [];
+    }
+  }
+
+  private async collectGitInfo(): Promise<GitInfo | null> {
+    try {
+      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
+        console.log('ℹ️  No git remote configured, skipping remote info');
+      }
+      
+      const isDirty = execSync('git status --porcelain', { encoding: 'utf-8' }).trim().length > 0;
+      
+      return {
+        branch,
+        commit,
+        shortCommit,
+        author,
+        commitMessage,
+        commitTimestamp,
+        isDirty,
+        remoteName,
+        remoteUrl
+      };
+    } catch (error: any) {
+      console.warn('Could not collect Git information:', error.message);
+      return null;
+    }
+  }
+
+  private getArtifactType(name: string): string {
+    if (name.includes('screenshot')) return 'screenshot';
+    if (name.includes('video')) return 'video';
+    if (name.includes('trace')) return 'trace';
+    return 'attachment';
+  }
+
+  private extractTags(test: TestCase): string[] {
+    const tags: string[] = [];
+    
+    test.annotations.forEach((annotation: any) => {
+      if (annotation.type === 'tag' && annotation.description) {
+        tags.push(annotation.description);
+      }
+    });
+
+    const tagMatches = test.title.match(/@[\w-]+/g);
+    if (tagMatches) {
+      tags.push(...tagMatches);
+    }
+
+    return tags;
+  }
+
+  private getTestId(test: TestCase): string {
+    const cleanTitle = test.title.replace(/@[\w-]+/g, '').trim();
+    return `${test.location.file}:${test.location.line}:${cleanTitle}`;
+  }
+
+  private async uploadArtifactToS3(filePath: string, testId: string, fileName: string): Promise<{ key: string; url: string; presignedUrl: string; fileSize: number; contentType: string }> {
+    try {
+      const fileContent = fs.readFileSync(filePath);
+      const fileSize = fileContent.length;
+      
+      // Get content type based on file extension
+      const ext = path.extname(filePath).toLowerCase();
+      const contentType = this.getContentType(ext);
+      
+      // Generate S3 key
+      const s3Key = this.generateS3Key(this.runId, testId, fileName);
+      
+      const uploadParams = {
+        Bucket: EMBEDDED_CONFIG.S3_BUCKET_NAME,
+        Key: s3Key,
+        Body: fileContent,
+        ContentType: contentType,
+        ACL: (EMBEDDED_CONFIG.S3_ACL as 'private' | 'public-read' | undefined) || 'private',
+      };
+      
+      await this.s3Client!.send(new PutObjectCommand(uploadParams));
+      
+      // Generate presigned URL for frontend access (expires in 7 days)
+      const getCommand = new GetObjectCommand({
+        Bucket: EMBEDDED_CONFIG.S3_BUCKET_NAME,
+        Key: s3Key
+      });
+      
+      const presignedUrl = await getSignedUrl(this.s3Client!, getCommand, { 
+        expiresIn: 604800 // 7 days
+      });
+      
+      const s3Url = `https://${EMBEDDED_CONFIG.S3_BUCKET_NAME}.s3.${EMBEDDED_CONFIG.AWS_REGION || 'us-east-1'}.amazonaws.com/${s3Key}`;
+      
+      return {
+        key: s3Key,
+        url: s3Url,
+        presignedUrl: presignedUrl,
+        fileSize,
+        contentType
+      };
+    } catch (error) {
+      console.error(`❌ Failed to upload ${fileName} to S3:`, (error as Error).message);
+      throw error;
+    }
+  }
+
+  private getContentType(ext: string): string {
+    const contentTypes: { [key: string]: string } = {
+      '.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';
+  }
+
+  private generateS3Key(runId: string, testId: string, fileName: string): string {
+    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}`;
+  }
+
+  private sanitizeForS3(value: string): string {
+    return value
+      .replace(/[\/:*?"<>|]/g, '-')
+      .replace(/[-\u001f\u007f]/g, '-')
+      .replace(/[^-~]/g, '-')
+      .replace(/\s+/g, '-')
+      .replace(/[_]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+  }
+
+  private getFileSize(filePath: string): number {
+    try {
+      const stats = fs.statSync(filePath);
+      return stats.size;
+    } catch (error) {
+      console.warn(`Could not get file size for ${filePath}:`, (error as Error).message);
+      return 0;
+    }
+  }
+}
+
+export default TestLensReporter;