testlens-playwright-reporter 0.1.0 → 0.1.2

package/index.d.ts

@@ -11,8 +11,6 @@ export interface TestLensReporterConfig {
   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 */
@@ -38,8 +36,6 @@ export interface TestLensReporterOptions {
   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 */

package/index.js

@@ -2,36 +2,24 @@ 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 { S3Client, PutObjectCommand, GetObjectCommand } = require('@aws-sdk/client-s3');
-const { getSignedUrl } = require('@aws-sdk/s3-request-presigner');
 const mime = require('mime');
-
-// Load environment variables from .env file
-// 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"
-};
-
+const FormData = require('form-data');
 class TestLensReporter {
   constructor(options = {}) {
     this.config = {
-      apiEndpoint: EMBEDDED_CONFIG.TEST_API_ENDPOINT || options.apiEndpoint || '',
+      apiEndpoint: 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,
-      ...options
+      rejectUnauthorized: options.rejectUnauthorized !== false, // Default to true for security
+      ignoreSslErrors: options.ignoreSslErrors === true // Explicit opt-in to ignore SSL errors
     };
 
     if (!this.config.apiEndpoint) {
@@ -42,38 +30,25 @@ class TestLensReporter {
       throw new Error('API_KEY is required for TestLensReporter. Pass it as apiKey option in your playwright config.');
     }
 
-    // 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 = {
-          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
-          };
-        }
-        
-        if (process.env.AWS_ENDPOINT) {
-          s3Config.endpoint = process.env.AWS_ENDPOINT;
-          s3Config.forcePathStyle = true;
-        }
-        
-        this.s3Client = new S3Client(s3Config);
-        console.log('✅ S3 client initialized for artifact uploads');
-      } catch (error) {
-        console.error('❌ Failed to initialize S3 client:', error.message);
-        this.s3Enabled = false;
-      }
+    // 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
+    // Set up axios instance with retry logic and enhanced SSL handling
     this.axiosInstance = axios.create({
       baseURL: this.config.apiEndpoint,
       timeout: this.config.timeout,
@@ -81,6 +56,13 @@ class TestLensReporter {
         '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
@@ -374,27 +356,20 @@ class TestLensReporter {
           if (attachment.path) {
             try {
               console.log(`📤 Processing ${attachment.name} asynchronously...`);
-              let s3Data = null;
-
-              // Upload to S3 if enabled
-              if (this.s3Enabled && this.s3Client) {
-                s3Data = await this.uploadArtifactToS3(attachment.path, testId, attachment.name);
-                console.log(`✅ S3 upload completed for ${attachment.name}`);
-              }
-
+              
+              // Upload to S3 first
+              const 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'
-                })
+                fileSize: this.getFileSize(attachment.path),
+                storageType: 's3',
+                s3Key: s3Data.key,
+                s3Url: s3Data.url
               };
 
               // Send artifact data to API
@@ -405,7 +380,7 @@ class TestLensReporter {
                 artifact: artifactData
               });
 
-              console.log(`📎 Processed artifact: ${attachment.name}${s3Data ? ' (uploaded to S3)' : ''}`);
+              console.log(`📎 Processed artifact: ${attachment.name} (uploaded to S3)`);
             } catch (error) {
               console.error(`❌ Failed to process ${attachment.name}:`, error.message);
             }
@@ -584,86 +559,6 @@ class TestLensReporter {
     return `${test.location.file}:${test.location.line}:${cleanTitle}`;
   }
 
-  async uploadArtifactToS3(filePath, testId, fileName) {
-    console.log(`🔄 Starting S3 upload for ${fileName}...`);
-    try {
-      const fileContent = fs.readFileSync(filePath);
-      const fileSize = fileContent.length;
-      console.log(`📏 File size: ${fileSize} bytes`);
-      
-      // Get content type based on file extension
-      const ext = path.extname(filePath).toLowerCase();
-      const contentType = this.getContentType(ext);
-      console.log(`📄 Content type: ${contentType}`);
-      
-      // Generate S3 key
-      const s3Key = this.generateS3Key(this.runId, testId, fileName);
-      console.log(`🔑 S3 key: ${s3Key}`);
-      
-      const uploadParams = {
-        Bucket: EMBEDDED_CONFIG.S3_BUCKET_NAME,
-        Key: s3Key,
-        Body: fileContent,
-        ContentType: contentType,
-        ACL: EMBEDDED_CONFIG.S3_ACL || 'private',
-        ServerSideEncryption: process.env.S3_SSE || 'AES256'
-      };
-      
-      console.log(`☁️ Uploading to S3 bucket: ${EMBEDDED_CONFIG.S3_BUCKET_NAME}`);
-      await this.s3Client.send(new PutObjectCommand(uploadParams));
-      console.log(`✅ S3 upload completed for ${fileName}`);
-      
-      // Generate presigned URL for frontend access (expires in 7 days)
-      console.log(`🔗 Generating presigned URL for ${fileName}...`);
-      const getCommand = new GetObjectCommand({
-        Bucket: EMBEDDED_CONFIG.S3_BUCKET_NAME,
-        Key: s3Key
-      });
-      
-      const presignedUrl = await getSignedUrl(this.s3Client, getCommand, { 
-        expiresIn: 604800 // 7 days
-      });
-      console.log(`✅ Presigned URL generated for ${fileName}`);
-      
-      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.message);
-      console.error(`❌ Error details:`, error);
-      throw error;
-    }
-  }
-
-  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, '/') // Convert Windows backslashes to forward slashes first
-      .replace(/[\/:*?"<>|]/g, '-')
-      .replace(/[\x00-\x1f\x7f]/g, '-')
-      .replace(/[^ -~]/g, '-')
-      .replace(/\s+/g, '-')
-      .replace(/[_]/g, '-')
-      .replace(/-+/g, '-')
-      .replace(/^-|-$/g, '')
-      .replace(/\/{2,}/g, '/'); // Remove multiple consecutive slashes
-  }
-
   getContentType(ext) {
     const contentTypes = {
       '.mp4': 'video/mp4',
@@ -691,6 +586,62 @@ class TestLensReporter {
       return 0;
     }
   }
+
+  async uploadArtifactToS3(filePath, testId, fileName) {
+    try {
+      // Use the public S3 upload API endpoint
+      const baseUrl = this.config.apiEndpoint.replace('/api/v1/webhook/playwright', '');
+      const uploadUrl = `${baseUrl}/api/v1/artifacts/public/upload`;
+
+      // Prepare form data for multipart upload
+      const form = new FormData();
+
+      // Add required fields
+      form.append('apiKey', this.config.apiKey);
+      form.append('testRunId', this.runId);
+      form.append('testId', testId);
+      form.append('artifactType', this.getArtifactType(fileName));
+      form.append('file', fs.createReadStream(filePath), {
+        filename: fileName,
+        contentType: this.getContentType(fileName)
+      });
+
+      console.log(`📤 Uploading ${fileName} to TestLens S3 via API...`);
+
+      // Make the upload request
+      const response = await this.axiosInstance.post(uploadUrl, form, {
+        headers: {
+          ...form.getHeaders(),
+          // Override content-type to let form-data set it
+          'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`
+        },
+        timeout: 60000 // 60 second timeout for uploads
+      });
+
+      if (response.status === 201 && response.data.success) {
+        const artifact = response.data.artifact;
+        console.log(`✅ S3 upload completed for ${fileName}`);
+        return {
+          key: artifact.s3Key,
+          url: artifact.s3Url,
+          presignedUrl: artifact.presignedUrl,
+          fileSize: artifact.fileSize,
+          contentType: artifact.contentType
+        };
+      } else {
+        throw new Error(`Upload failed: ${response.data.error || 'Unknown error'}`);
+      }
+    } catch (error) {
+      console.error(`❌ Failed to upload ${fileName} to TestLens S3 API:`, error.message);
+      throw error; // Re-throw to prevent fallback to local storage
+    }
+  }
+
+  getContentType(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    const mimeType = mime.getType(ext) || 'application/octet-stream';
+    return mimeType;
+  }
 }
 
 module.exports = TestLensReporter;

package/index.ts

@@ -4,22 +4,10 @@ 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 type { 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"
-};
-
+import FormData from 'form-data';
 export interface TestLensReporterConfig {
   /** TestLens API endpoint URL */
   apiEndpoint?: string;
@@ -31,8 +19,6 @@ export interface TestLensReporterConfig {
   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 */
@@ -58,8 +44,6 @@ export interface TestLensReporterOptions {
   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 */
@@ -147,8 +131,6 @@ export interface SpecData {
 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>;
@@ -156,12 +138,11 @@ export class TestLensReporter implements Reporter {
 
   constructor(options: TestLensReporterOptions) {
     this.config = {
-      apiEndpoint: EMBEDDED_CONFIG.TEST_API_ENDPOINT || options.apiEndpoint || '',
+      apiEndpoint: 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,
@@ -235,32 +216,6 @@ export class TestLensReporter implements Reporter {
       }
     );
 
-    // 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>();
@@ -460,7 +415,7 @@ export class TestLensReporter implements Reporter {
     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;
+    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;
@@ -488,15 +443,20 @@ export class TestLensReporter implements Reporter {
 
   private async sendToApi(payload: any): Promise<void> {
     try {
+      console.log(`📤 Sending ${payload.type} event to ${this.config.apiEndpoint}`);
       const response = await this.axiosInstance.post('', payload);
       if (this.config.enableRealTimeStream) {
-        console.log(`✅ Sent ${payload.type} event to TestLens`);
+        console.log(`✅ Sent ${payload.type} event to TestLens (HTTP ${response.status})`);
       }
     } 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
+        statusText: error?.response?.statusText,
+        data: error?.response?.data,
+        code: error?.code,
+        url: error?.config?.url,
+        method: error?.config?.method
       });
       
       // Don't throw error to avoid breaking test execution
@@ -509,12 +469,8 @@ export class TestLensReporter implements Reporter {
     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);
-          }
+          // Upload to S3 first
+          const s3Data = await this.uploadArtifactToS3(attachment.path, testId, attachment.name);
           
           const artifactData = {
             testId,
@@ -522,13 +478,10 @@ export class TestLensReporter implements Reporter {
             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'
-            })
+            fileSize: this.getFileSize(attachment.path),
+            storageType: 's3',
+            s3Key: s3Data.key,
+            s3Url: s3Data.url
           };
 
           // Send artifact data to API
@@ -539,7 +492,7 @@ export class TestLensReporter implements Reporter {
             artifact: artifactData
           });
           
-          console.log(`📎 Processed artifact: ${attachment.name}${s3Data ? ' (uploaded to S3)' : ''}`);
+          console.log(`📎 Processed artifact: ${attachment.name} (uploaded to S3)`);
         } catch (error) {
           console.error(`❌ Failed to process artifact ${attachment.name}:`, (error as Error).message);
         }
@@ -714,69 +667,65 @@ export class TestLensReporter implements Reporter {
     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
+      // Use the new public S3 upload API endpoint instead of direct AWS SDK calls
+      const baseUrl = this.config.apiEndpoint.replace('/api/v1/webhook/playwright', '');
+      const uploadUrl = `${baseUrl}/api/v1/artifacts/public/upload`;
+
+      // Prepare form data for multipart upload
+      const form = new FormData();
+
+      // Add required fields
+      form.append('apiKey', this.config.apiKey);
+      form.append('testRunId', this.runId);
+      form.append('testId', testId);
+      form.append('artifactType', this.getArtifactType(fileName));
+      form.append('file', fs.createReadStream(filePath), {
+        filename: fileName,
+        contentType: this.getContentType(fileName)
       });
-      
-      const presignedUrl = await getSignedUrl(this.s3Client!, getCommand, { 
-        expiresIn: 604800 // 7 days
+
+      console.log(`📤 Uploading ${fileName} to TestLens S3 via API...`);
+
+      // Make the upload request
+      const response = await this.axiosInstance.post(uploadUrl, form, {
+        headers: {
+          ...form.getHeaders(),
+          // Override content-type to let form-data set it
+          'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`
+        },
+        timeout: 60000 // 60 second timeout for uploads
       });
-      
-      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
-      };
+
+      if (response.status === 201 && response.data.success) {
+        const artifact = response.data.artifact;
+        console.log(`✅ S3 upload completed for ${fileName}`);
+
+        // Extract S3 key from URL if not provided
+        const s3Key = artifact.s3Key || artifact.s3Url.split('/').slice(-1)[0];
+
+        return {
+          key: s3Key,
+          url: artifact.s3Url,
+          presignedUrl: artifact.presignedUrl,
+          fileSize: artifact.fileSize,
+          contentType: artifact.contentType
+        };
+      } else {
+        throw new Error(`Upload failed: ${response.data.error || 'Unknown error'}`);
+      }
     } catch (error) {
-      console.error(`❌ Failed to upload ${fileName} to S3:`, (error as Error).message);
-      throw error;
+      console.error(`❌ Failed to upload ${fileName} to TestLens S3 API:`, (error as Error).message);
+      throw error; // Re-throw to prevent fallback to local storage
     }
   }
 
-  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 getContentType(fileName: string): string {
+    const ext = path.extname(fileName).toLowerCase();
+    const mimeType = mime.default.getType(ext) || 'application/octet-stream';
+    return mimeType;
   }
 
   private generateS3Key(runId: string, testId: string, fileName: string): string {

package/lib/index.js

@@ -44,26 +44,16 @@ const fs = __importStar(require("fs"));
 const https = __importStar(require("https"));
 const axios_1 = __importDefault(require("axios"));
 const child_process_1 = require("child_process");
-const client_s3_1 = require("@aws-sdk/client-s3");
-const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
-// 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"
-};
+const mime = __importStar(require("mime"));
+const form_data_1 = __importDefault(require("form-data"));
 class TestLensReporter {
     constructor(options) {
         this.config = {
-            apiEndpoint: EMBEDDED_CONFIG.TEST_API_ENDPOINT || options.apiEndpoint || '',
+            apiEndpoint: 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,
@@ -126,29 +116,6 @@ class TestLensReporter {
             }
             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 = {
-                    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 client_s3_1.S3Client(s3Config);
-                console.log('✅ S3 client initialized for artifact uploads');
-            }
-            catch (error) {
-                console.error('❌ Failed to initialize S3 client:', error.message);
-                this.s3Enabled = false;
-            }
-        }
         this.runId = (0, crypto_1.randomUUID)();
         this.runMetadata = this.initializeRunMetadata();
         this.specMap = new Map();
@@ -325,7 +292,7 @@ class TestLensReporter {
         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;
+        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);
@@ -349,16 +316,21 @@ class TestLensReporter {
     }
     async sendToApi(payload) {
         try {
+            console.log(`📤 Sending ${payload.type} event to ${this.config.apiEndpoint}`);
             const response = await this.axiosInstance.post('', payload);
             if (this.config.enableRealTimeStream) {
-                console.log(`✅ Sent ${payload.type} event to TestLens`);
+                console.log(`✅ Sent ${payload.type} event to TestLens (HTTP ${response.status})`);
             }
         }
         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
+                statusText: error?.response?.statusText,
+                data: error?.response?.data,
+                code: error?.code,
+                url: error?.config?.url,
+                method: error?.config?.method
             });
             // Don't throw error to avoid breaking test execution
         }
@@ -368,24 +340,18 @@ class TestLensReporter {
         for (const attachment of attachments) {
             if (attachment.path) {
                 try {
-                    let s3Data = null;
-                    // Upload to S3 if enabled
-                    if (this.s3Enabled && this.s3Client) {
-                        s3Data = await this.uploadArtifactToS3(attachment.path, testId, attachment.name);
-                    }
+                    // Upload to S3 first
+                    const 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'
-                        })
+                        fileSize: this.getFileSize(attachment.path),
+                        storageType: 's3',
+                        s3Key: s3Data.key,
+                        s3Url: s3Data.url
                     };
                     // Send artifact data to API
                     await this.sendToApi({
@@ -394,7 +360,7 @@ class TestLensReporter {
                         timestamp: new Date().toISOString(),
                         artifact: artifactData
                     });
-                    console.log(`📎 Processed artifact: ${attachment.name}${s3Data ? ' (uploaded to S3)' : ''}`);
+                    console.log(`📎 Processed artifact: ${attachment.name} (uploaded to S3)`);
                 }
                 catch (error) {
                     console.error(`❌ Failed to process artifact ${attachment.name}:`, error.message);
@@ -555,59 +521,56 @@ class TestLensReporter {
     }
     async uploadArtifactToS3(filePath, testId, fileName) {
         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 || 'private',
-            };
-            await this.s3Client.send(new client_s3_1.PutObjectCommand(uploadParams));
-            // Generate presigned URL for frontend access (expires in 7 days)
-            const getCommand = new client_s3_1.GetObjectCommand({
-                Bucket: EMBEDDED_CONFIG.S3_BUCKET_NAME,
-                Key: s3Key
+            // Use the new public S3 upload API endpoint instead of direct AWS SDK calls
+            const baseUrl = this.config.apiEndpoint.replace('/api/v1/webhook/playwright', '');
+            const uploadUrl = `${baseUrl}/api/v1/artifacts/public/upload`;
+            // Prepare form data for multipart upload
+            const form = new form_data_1.default();
+            // Add required fields
+            form.append('apiKey', this.config.apiKey);
+            form.append('testRunId', this.runId);
+            form.append('testId', testId);
+            form.append('artifactType', this.getArtifactType(fileName));
+            form.append('file', fs.createReadStream(filePath), {
+                filename: fileName,
+                contentType: this.getContentType(fileName)
             });
-            const presignedUrl = await (0, s3_request_presigner_1.getSignedUrl)(this.s3Client, getCommand, {
-                expiresIn: 604800 // 7 days
+            console.log(`📤 Uploading ${fileName} to TestLens S3 via API...`);
+            // Make the upload request
+            const response = await this.axiosInstance.post(uploadUrl, form, {
+                headers: {
+                    ...form.getHeaders(),
+                    // Override content-type to let form-data set it
+                    'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`
+                },
+                timeout: 60000 // 60 second timeout for uploads
             });
-            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
-            };
+            if (response.status === 201 && response.data.success) {
+                const artifact = response.data.artifact;
+                console.log(`✅ S3 upload completed for ${fileName}`);
+                // Extract S3 key from URL if not provided
+                const s3Key = artifact.s3Key || artifact.s3Url.split('/').slice(-1)[0];
+                return {
+                    key: s3Key,
+                    url: artifact.s3Url,
+                    presignedUrl: artifact.presignedUrl,
+                    fileSize: artifact.fileSize,
+                    contentType: artifact.contentType
+                };
+            }
+            else {
+                throw new Error(`Upload failed: ${response.data.error || 'Unknown error'}`);
+            }
         }
         catch (error) {
-            console.error(`❌ Failed to upload ${fileName} to S3:`, error.message);
-            throw error;
+            console.error(`❌ Failed to upload ${fileName} to TestLens S3 API:`, error.message);
+            throw error; // Re-throw to prevent fallback to local storage
         }
     }
-    getContentType(ext) {
-        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';
+    getContentType(fileName) {
+        const ext = path.extname(fileName).toLowerCase();
+        const mimeType = mime.default.getType(ext) || 'application/octet-stream';
+        return mimeType;
     }
     generateS3Key(runId, testId, fileName) {
         const date = new Date().toISOString().slice(0, 10);

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "testlens-playwright-reporter",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Universal Playwright reporter for TestLens - works with both TypeScript and JavaScript projects",
   "main": "lib/index.js",
   "types": "index.d.ts",
   "files": [
     "index.js",
-    "index.d.ts", 
-    "index.ts", 
+    "index.d.ts",
+    "index.ts",
     "lib/",
     "README.md",
     "CHANGELOG.md"
@@ -36,7 +36,7 @@
   "author": {
     "name": "TestLens Team",
     "email": "support@testlens.io",
-    "url": "https://testlens.io"
+    "url": "https://testlens.qa-path.com"
   },
   "license": "MIT",
   "peerDependencies": {
@@ -47,6 +47,7 @@
     "@aws-sdk/s3-request-presigner": "^3.624.0",
     "axios": "^1.11.0",
     "dotenv": "^16.4.5",
+    "form-data": "^4.0.1",
     "mime": "^4.0.4"
   },
   "engines": {

package/README.md

@@ -1,238 +0,0 @@
-````markdown
-# TestLens Playwright Reporter
-
-A modern, feature-rich Playwright reporter that works with both TypeScript and JavaScript projects, integrating seamlessly with your TestLens dashboard.
-
-## 🚀 Features
-
-- ✅ **Universal Compatibility** - Works with both TypeScript and JavaScript Playwright projects
-- 🔄 **Real-time Streaming** - Live test results streaming to TestLens dashboard
-- 📊 **Comprehensive Reporting** - Test results, artifacts, and detailed metrics
-- 🌿 **Git Integration** - Automatic collection of Git information (branch, commit, author, etc.)
-- 📝 **Code Block Extraction** - Intelligent extraction of test code for better debugging
-- 🔄 **Retry Logic** - Robust error handling and retry mechanisms
-- 🎯 **Artifact Support** - Screenshots, videos, traces, and custom attachments with S3 storage
-- ☁️ **S3 Integration** - Automatic upload of artifacts to Amazon S3 for persistent storage
-
-## 📦 Installation
-
-### Option 1: npm install (Recommended)
-
-```bash
-# Install the TestLens Playwright Reporter
-npm install @testlens/playwright-reporter --save-dev
-
-# Install the TestLens Playwright Reporter uisng the file locally
-npm install --save-dev ./testlens-playwright-reporter-x.y.z.tgz
-
-# Or using yarn
-yarn add @testlens/playwright-reporter --dev
-
-# Or using pnpm
-pnpm add -D @testlens/playwright-reporter
-```
-
-### Option 2: Use from centralized location
-
-```bash
-# Clone or copy the testlens-reporter to a central location
-git clone https://github.com/alternative-path/testlens-reporter.git D:\Experiment\AP\testlens-reporter
-
-# Install dependencies
-cd D:\Experiment\AP\testlens-reporter
-npm install
-
-# Reference from your Playwright projects using absolute path or environment variable
-```
-
-## ⚙️ Configuration
-
-### 1. Environment Variables
-
-No environment file is required! All configuration is embedded in the package. However, you can still override settings if needed by creating a `.env` file:
-
-```env
-# Optional: TestLens API endpoint (defaults to embedded configuration)
-TEST_API_ENDPOINT=http://localhost:3001/api/v1/webhook/playwright
-```
-
-**Note**: 
-- S3 configuration is pre-configured and embedded in the package. No additional S3 setup is required.
-- API key must be provided directly in your Playwright configuration file, not in environment variables.
-
-### 2. Playwright Configuration
-
-#### For JavaScript projects (`playwright.config.js`):
-
-```javascript
-// @ts-check
-const { defineConfig } = require('@playwright/test');
-
-module.exports = defineConfig({
-  // ... your existing config
-  
-  reporter: [
-    ['list'], // Keep the default console reporter
-    ['@testlens/playwright-reporter', {
-      // API key is required - provide it directly in config
-      apiKey: 'your-api-key-here', // Required: Your TestLens API key
-      // Optional overrides (these have embedded defaults)
-      apiEndpoint: 'http://localhost:3001/api/v1/webhook/playwright',
-      enableRealTimeStream: true,
-      enableGitInfo: true,
-      enableArtifacts: true,
-      enableS3Upload: true, // S3 configuration is embedded
-      retryAttempts: 3,
-      timeout: 30000
-    }]
-  ],
-  
-  // ... rest of your config
-});
-```
-
-#### For TypeScript projects (`playwright.config.ts`):
-
-```typescript
-import { defineConfig } from '@playwright/test';
-
-export default defineConfig({
-  // ... your existing config
-  
-  reporter: [
-    ['list'], // Keep the default console reporter
-    ['@testlens/playwright-reporter', {
-      // API key is required - provide it directly in config
-      apiKey: 'your-api-key-here', // Required: Your TestLens API key
-      // Optional overrides (these have embedded defaults)
-      apiEndpoint: 'http://localhost:3001/api/v1/webhook/playwright',
-      enableRealTimeStream: true,
-      enableGitInfo: true,
-      enableArtifacts: true,
-      enableS3Upload: true, // S3 configuration is embedded
-      retryAttempts: 3,
-      timeout: 30000
-    }]
-  ],
-  
-  // ... rest of your config
-});
-```
-
-## 🔧 Configuration Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `apiEndpoint` | string | `process.env.TEST_API_ENDPOINT` | **Required.** TestLens API endpoint URL |
-| `apiKey` | string | *none* | **Required.** API key for authentication - must be provided in config |
-| `enableRealTimeStream` | boolean | `true` | Enable real-time streaming of test events |
-| `enableGitInfo` | boolean | `true` | Enable Git information collection |
-| `enableArtifacts` | boolean | `true` | Enable artifact processing (screenshots, videos, etc.) |
-| `enableS3Upload` | boolean | `true` | Enable S3 upload for artifacts (S3 configuration is embedded in the package) |
-| `batchSize` | number | `10` | Batch size for API requests |
-| `flushInterval` | number | `5000` | Flush interval in milliseconds |
-| `retryAttempts` | number | `3` | Number of retry attempts for failed API calls |
-| `timeout` | number | `30000` | Request timeout in milliseconds |
-
-## 🚦 Usage
-
-Once configured, simply run your Playwright tests as usual:
-
-```bash
-# Run all tests
-npx playwright test
-
-# Run specific test file
-npx playwright test tests/login.spec.ts
-
-# Run tests in headed mode
-npx playwright test --headed
-
-# Run tests with specific reporter only
-npx playwright test --reporter=./testlens-reporter
-```
-
-## 📊 What Gets Reported
-
-### Test Execution Data
-- ✅ Test results (passed/failed/skipped)
-- ⏱️ Test duration and timing
-- 🔄 Retry attempts and status
-- 📝 Error messages and stack traces
-- 🏷️ Test annotations and tags
-
-### System Information
-- 🌿 Git branch, commit, author, and message
-- 💻 OS and Node.js version
-- 🎭 Playwright version
-- 🌍 Environment information
-
-### Artifacts
-- 📸 Screenshots
-- 🎥 Videos  
-- 🔍 Traces
-- 📎 Custom attachments
-- ☁️ **S3 Storage** - Automatic upload to Amazon S3 with presigned URLs for access
-
-### Code Blocks
-- 🧪 Extracted test code blocks
-- 📝 Test structure and context
-- 🔍 Searchable test content
-
-## 🐛 Troubleshooting
-
-### Common Issues
-
-#### 1. "TEST_API_ENDPOINT is required" error
-Make sure you have set the `TEST_API_ENDPOINT` environment variable or passed it as a configuration option.
-
-#### 2. Connection errors
-- Verify that your TestLens backend is running and accessible
-- Check firewall settings and network connectivity
-- Ensure the API endpoint URL is correct
-
-#### 3. Git information not collected
-- Ensure you're running tests from within a Git repository
-- Check that Git is installed and accessible from the command line
-- Git information collection can be disabled with `enableGitInfo: false`
-
-### Debug Mode
-
-Enable debug logging by setting environment variable:
-
-```bash
-DEBUG=testlens:* npx playwright test
-```
-
-## 🤝 Integration with TestLens Dashboard
-
-This reporter integrates with your TestLens dashboard to provide:
-
-- 📊 **Real-time Test Results** - See tests as they run
-- 📈 **Historical Trends** - Track test performance over time
-- 🔍 **Code Block Visualization** - View actual test code in the dashboard
-- 🌿 **Git Integration** - Link test results to commits and branches
-- 📱 **Artifact Gallery** - Browse screenshots, videos, and traces
-
-## 📄 License
-
-MIT License - see LICENSE file for details.
-
-## 🤝 Contributing
-
-1. Fork the repository
-2. Create your feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add some amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
-
-## 📞 Support
-
-For issues and questions:
-- 🐛 [Report bugs](https://github.com/alternative-path/testlens/issues)
-- 💬 [Discussions](https://github.com/alternative-path/testlens/discussions)
-- 📧 [Email support](mailto:support@testlens.io)
-
-````
-node build-embed-env.js
-npm pack