@alternative-path/testlens-playwright-reporter 0.4.2 → 0.4.4

package/index.ts

@@ -3,7 +3,6 @@ import * as os from 'os';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as https from 'https';
-import * as tls from 'tls';
 import axios, { AxiosInstance } from 'axios';
 import type { Reporter, TestCase, TestResult, FullConfig, Suite } from '@playwright/test/reporter';
 import { execSync } from 'child_process';
@@ -47,8 +46,6 @@ export interface TestLensReporterConfig {
   rejectUnauthorized?: boolean;
   /** Alternative SSL option - set to true to ignore SSL certificate errors */
   ignoreSslErrors?: boolean;
-  /** Path to a custom CA certificate file (PEM format) to use for SSL verification */
-  caCertificate?: string;
   /** Custom metadata from CLI arguments (automatically parsed from --key=value arguments) */
   customMetadata?: Record<string, string | string[]>;
 }
@@ -80,8 +77,6 @@ export interface TestLensReporterOptions {
   rejectUnauthorized?: boolean;
   /** Alternative SSL option - set to true to ignore SSL certificate errors */
   ignoreSslErrors?: boolean;
-  /** Path to a custom CA certificate file (PEM format) to use for SSL verification */
-  caCertificate?: string;
   /** Custom metadata from CLI arguments (automatically parsed from --key=value arguments) */
   customMetadata?: Record<string, string | string[]>;
 }
@@ -118,6 +113,7 @@ export interface RunMetadata {
   os: string;
   playwrightVersion: string;
   nodeVersion: string;
+  testlensVersion?: string;
   gitInfo?: GitInfo | null;
   shardInfo?: {
     current: number;
@@ -183,118 +179,13 @@ export interface SpecData {
 export class TestLensReporter implements Reporter {
   private config: Required<TestLensReporterConfig>;
   private axiosInstance: AxiosInstance;
-
-  /**
-   * Get bundled CA certificates for TestLens
-   * Combines custom CA bundle with Node.js root certificates
-   * This ensures SSL works with both testlens.qa-path.com and other HTTPS endpoints
-   */
-  private static getBundledCaCertificates(): Buffer[] | undefined {
-    const allCerts: Buffer[] = [];
-
-    // First, add our bundled TestLens CA certificate chain
-    try {
-      const certPath = path.join(__dirname, 'testlens-ca-bundle.pem');
-      if (fs.existsSync(certPath)) {
-        const certData = fs.readFileSync(certPath, 'utf8');
-        // Split the bundle into individual certificates
-        const certs = certData.match(/-----BEGIN CERTIFICATE-----[\s\S]+?-----END CERTIFICATE-----/g);
-        if (certs && certs.length > 0) {
-          const buffers = certs.map(cert => Buffer.from(cert, 'utf8'));
-          allCerts.push(...buffers);
-          if (process.env.DEBUG) {
-            console.log(`✓ Loaded bundled TestLens CA certificates (${buffers.length} certificate(s))`);
-          }
-        }
-      }
-    } catch (error) {
-      if (process.env.DEBUG) {
-        console.log('⚠️  Bundled CA certificate not available');
-      }
-    }
-
-    // Then, add Node.js built-in root certificates for general SSL support
-    try {
-      if (tls.rootCertificates && Array.isArray(tls.rootCertificates) && tls.rootCertificates.length > 0) {
-        const rootCerts = tls.rootCertificates.map(cert => Buffer.from(cert, 'utf8'));
-        allCerts.push(...rootCerts);
-        if (process.env.DEBUG) {
-          console.log(`✓ Added Node.js built-in root certificates (${rootCerts.length} certificates)`);
-        }
-      }
-    } catch (error) {
-      if (process.env.DEBUG) {
-        console.log('⚠️  Node.js built-in root certificates not available');
-      }
-    }
-
-    return allCerts.length > 0 ? allCerts : undefined;
-  }
-
-  /**
-   * Automatically detect and load system CA certificates
-   * Uses bundled certificates as primary source, falls back to system certificates
-   */
-  private static getSystemCaCertificates(): Buffer[] | undefined {
-    // First, try to use our bundled certificates (Node.js rootCertificates)
-    const bundledCerts = TestLensReporter.getBundledCaCertificates();
-    if (bundledCerts && bundledCerts.length > 0) {
-      return bundledCerts;
-    }
-
-    // Fallback: Try to load from file system (for older Node.js versions or special cases)
-    const platform = os.platform();
-    const certificates: Buffer[] = [];
-    const certPaths: string[] = [];
-
-    if (platform === 'darwin') {
-      // macOS: Common certificate locations
-      certPaths.push(
-        '/etc/ssl/cert.pem',
-        '/usr/local/etc/openssl/cert.pem',
-        '/opt/homebrew/etc/openssl/cert.pem',
-        '/System/Library/OpenSSL/certs/cert.pem'
-      );
-    } else {
-      // Linux and other Unix-like systems
-      certPaths.push(
-        '/etc/ssl/certs/ca-certificates.crt',
-        '/etc/ssl/certs/ca-bundle.crt',
-        '/etc/pki/tls/certs/ca-bundle.crt',
-        '/etc/ssl/ca-bundle.pem',
-        '/usr/share/ssl/certs/ca-bundle.crt',
-        '/usr/local/share/certs/ca-root-nss.crt',
-        '/etc/ca-certificates/extracted/tls-ca-bundle.pem'
-      );
-    }
-
-    // Try to load certificates from common locations
-    for (const certPath of certPaths) {
-      try {
-        if (certPath && fs.existsSync(certPath)) {
-          const certData = fs.readFileSync(certPath);
-          certificates.push(certData);
-          // Only log in debug mode to avoid noise
-          if (process.env.DEBUG) {
-            console.log(`✓ Loaded CA certificates from: ${certPath}`);
-          }
-        }
-      } catch (error) {
-        // Silently continue if a certificate file can't be read
-        // This is expected as not all paths will exist on every system
-      }
-    }
-
-    // Return undefined if no certificates found (let Node.js use defaults)
-    // Return certificates array if we found any
-    return certificates.length > 0 ? certificates : undefined;
-  }
   private runId: string;
   private runMetadata: RunMetadata;
   private specMap: Map<string, SpecData>;
   private testMap: Map<string, TestData>;
   private runCreationFailed: boolean = false; // Track if run creation failed due to limits
   private cliArgs: Record<string, any> = {}; // Store CLI args separately
+  private pendingUploads: Set<Promise<any>> = new Set(); // Track pending artifact uploads
 
   /**
    * Parse custom metadata from environment variables
@@ -379,44 +270,6 @@ export class TestLensReporter implements Reporter {
 
     // Determine SSL validation behavior
     let rejectUnauthorized = true; // Default to secure
-    let ca: Buffer | string | Buffer[] | undefined = undefined;
-
-    // Use bundled CA certificates as primary source (Node.js rootCertificates)
-    // This ensures consistent behavior across all platforms
-    const bundledCerts = TestLensReporter.getBundledCaCertificates();
-    
-    // Load custom CA certificate if explicitly provided (for advanced users)
-    // Custom certificates will be combined with bundled certificates
-    if (this.config.caCertificate) {
-      try {
-        if (fs.existsSync(this.config.caCertificate)) {
-          const customCert = fs.readFileSync(this.config.caCertificate);
-          // Combine bundled certs with custom cert
-          if (bundledCerts && Array.isArray(bundledCerts) && bundledCerts.length > 0) {
-            ca = [...bundledCerts, customCert];
-            console.log(`✓ Using bundled CA certificates + custom certificate: ${this.config.caCertificate}`);
-          } else {
-            ca = customCert;
-            console.log(`✓ Using custom CA certificate: ${this.config.caCertificate}`);
-          }
-        } else {
-          console.warn(`⚠️  CA certificate file not found: ${this.config.caCertificate}`);
-          // Fall back to bundled certs if custom cert not found
-          ca = bundledCerts || undefined;
-        }
-      } catch (error) {
-        console.warn(`⚠️  Failed to read CA certificate file: ${this.config.caCertificate}`, (error as Error).message);
-        // Fall back to bundled certs if custom cert read fails
-        ca = bundledCerts || undefined;
-      }
-    } else {
-      // Use bundled certificates as primary source
-      // This works reliably across all platforms (Windows, macOS, Linux)
-      ca = bundledCerts || undefined;
-      if (ca && process.env.DEBUG) {
-        console.log(`✓ Using bundled CA certificates (${Array.isArray(ca) ? ca.length : 1} certificates)`);
-      }
-    }
 
     // Check various ways SSL validation can be disabled (in order of precedence)
     if (this.config.ignoreSslErrors) {
@@ -434,25 +287,6 @@ export class TestLensReporter implements Reporter {
     }
 
     // Set up axios instance with retry logic and enhanced SSL handling
-    const httpsAgentOptions: https.AgentOptions = {
-      rejectUnauthorized: rejectUnauthorized,
-      // Allow any TLS version for better compatibility
-      minVersion: 'TLSv1.2',
-      maxVersion: 'TLSv1.3'
-    };
-
-    // Add CA certificates if available
-    // On Windows, ca will be undefined to let Node.js use Windows certificate store automatically
-    // On Unix systems, ca will contain certificates if found, or undefined to use Node.js defaults
-    if (ca !== undefined) {
-      if (Array.isArray(ca) && ca.length > 0) {
-        httpsAgentOptions.ca = ca;
-      } else if (typeof ca === 'string' || Buffer.isBuffer(ca)) {
-        httpsAgentOptions.ca = ca;
-      }
-      // If ca is undefined, we don't set it, allowing Node.js to use its default certificate store
-    }
-
     this.axiosInstance = axios.create({
       baseURL: this.config.apiEndpoint,
       timeout: this.config.timeout,
@@ -461,7 +295,12 @@ export class TestLensReporter implements Reporter {
         ...(this.config.apiKey && { 'X-API-Key': this.config.apiKey }),
       },
       // Enhanced SSL handling with flexible TLS configuration
-      httpsAgent: new https.Agent(httpsAgentOptions)
+      httpsAgent: new https.Agent({
+        rejectUnauthorized: rejectUnauthorized,
+        // Allow any TLS version for better compatibility
+        minVersion: 'TLSv1.2',
+        maxVersion: 'TLSv1.3'
+      })
     });
 
     // Add retry interceptor
@@ -510,7 +349,8 @@ export class TestLensReporter implements Reporter {
       browser: 'multiple',
       os: `${os.type()} ${os.release()}`,
       playwrightVersion: this.getPlaywrightVersion(),
-      nodeVersion: process.version
+      nodeVersion: process.version,
+      testlensVersion: this.getTestLensVersion()
     };
     
     // Add custom metadata if provided
@@ -537,6 +377,15 @@ export class TestLensReporter implements Reporter {
     }
   }
 
+  private getTestLensVersion(): string {
+    try {
+      const testlensPackage = require('./package.json');
+      return testlensPackage.version;
+    } catch (error) {
+      return 'unknown';
+    }
+  }
+
   private normalizeTestStatus(status: string): string {
     // Treat timeout as failed for consistency with analytics
     if (status === 'timedOut') {
@@ -846,25 +695,21 @@ export class TestLensReporter implements Reporter {
         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 and get response
-        const testEndResponse = await this.sendToApi({
-          type: 'testEnd',
-          runId: this.runId,
-          timestamp: new Date().toISOString(),
-          test: testData
-        });
+      // Send testEnd event for all tests, regardless of status
+      // This ensures tests that are interrupted or have unexpected statuses are properly recorded
+      console.log(`[TestLens] Sending testEnd - testId: ${testData.id}, status: ${testData.status}, originalStatus: ${testData.originalStatus}`);
+      // Send test end event to API and get response
+      const testEndResponse = await this.sendToApi({
+        type: 'testEnd',
+        runId: this.runId,
+        timestamp: new Date().toISOString(),
+        test: testData
+      });
 
-        // Handle artifacts (test case is now guaranteed to be in database)
-        if (this.config.enableArtifacts) {
-          // Pass test case DB ID if available for faster lookups
-          await this.processArtifacts(testId, result, testEndResponse?.testCaseId);
-        }
+      // Handle artifacts (test case is now guaranteed to be in database)
+      if (this.config.enableArtifacts) {
+        // Pass test case DB ID if available for faster lookups
+        await this.processArtifacts(testId, result, testEndResponse?.testCaseId);
       }
     }
 
@@ -881,13 +726,33 @@ export class TestLensReporter implements Reporter {
       }
 
       // Check if all tests in spec are complete
+      // Only consider tests that were actually executed (have testData)
       const remainingTests = test.parent.tests.filter((t: any) => {
         const tId = this.getTestId(t);
         const tData = this.testMap.get(tId);
-        return !tData || !tData.endTime;
+        // If testData exists but no endTime, it's still running
+        return tData && !tData.endTime;
       });
 
       if (remainingTests.length === 0) {
+        // Determine final spec status based on all executed tests
+        const executedTests = test.parent.tests
+          .map((t: any) => {
+            const tId = this.getTestId(t);
+            return this.testMap.get(tId);
+          })
+          .filter((tData: TestData | undefined): tData is TestData => !!tData);
+        
+        if (executedTests.length > 0) {
+          const allTestStatuses = executedTests.map(tData => tData.status);
+          if (allTestStatuses.every(status => status === 'passed')) {
+            specData.status = 'passed';
+          } else if (allTestStatuses.some(status => status === 'failed')) {
+            specData.status = 'failed';
+          } else if (allTestStatuses.every(status => status === 'skipped')) {
+            specData.status = 'skipped';
+          }
+        }
         // Aggregate tags from all tests in this spec
         const allTags = new Set<string>();
         test.parent.tests.forEach((t: any) => {
@@ -920,6 +785,17 @@ export class TestLensReporter implements Reporter {
     this.runMetadata.endTime = new Date().toISOString();
     this.runMetadata.duration = Date.now() - new Date(this.runMetadata.startTime).getTime();
 
+    // Wait for all pending artifact uploads to complete before sending runEnd
+    if (this.pendingUploads.size > 0) {
+      console.log(`⏳ Waiting for ${this.pendingUploads.size} artifact upload(s) to complete...`);
+      try {
+        await Promise.all(Array.from(this.pendingUploads));
+        console.log(`✅ All artifact uploads completed`);
+      } catch (error) {
+        console.error(`⚠️  Some artifact uploads failed, continuing with runEnd`);
+      }
+    }
+
     // Calculate final stats
     const totalTests = Array.from(this.testMap.values()).length;
     const passedTests = Array.from(this.testMap.values()).filter(t => t.status === 'passed').length;
@@ -1039,68 +915,17 @@ export class TestLensReporter implements Reporter {
         } else {
           console.error(`❌ Authentication failed: ${errorData?.error || 'Invalid API key'}`);
         }
-      } else {
-        // Check for SSL certificate errors
-        const isSslError = error?.code === 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY' || 
-                          error?.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE' ||
-                          error?.code === 'CERT_HAS_EXPIRED' ||
-                          error?.code === 'SELF_SIGNED_CERT_IN_CHAIN' ||
-                          error?.message?.includes('certificate') ||
-                          error?.message?.includes('SSL') ||
-                          error?.message?.includes('TLS');
-
-        if (isSslError && status !== 403) {
-          console.error('\n' + '='.repeat(80));
-          console.error('❌ SSL Certificate Error');
-          console.error('='.repeat(80));
-          console.error('');
-          console.error(`Failed to send ${payload.type} event to TestLens due to SSL certificate issue.`);
-          console.error('');
-          console.error('The reporter automatically attempts to detect and use system CA certificates.');
-          console.error('If this error persists, it may indicate:');
-          console.error('  - Missing or outdated system CA certificates');
-          console.error('  - Corporate proxy with custom CA certificate');
-          console.error('  - Incomplete certificate chain from the server');
-          console.error('');
-          console.error('Error details:');
-          console.error(`  Code: ${error?.code || 'Unknown'}`);
-          console.error(`  Message: ${error?.message || 'Unknown error'}`);
-          console.error('');
-          console.error('Possible solutions:');
-          console.error('');
-          console.error('1. Update your system\'s CA certificate store:');
-          console.error('   - Windows: Update Windows root certificates via Windows Update');
-          console.error('   - macOS: Run: sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain <certificate.pem>');
-          console.error('   - Linux: Update ca-certificates package: sudo apt-get update && sudo apt-get install ca-certificates');
-          console.error('');
-          console.error('2. If you have a custom CA certificate file (e.g., from corporate proxy),');
-          console.error('   you can specify it in your config (optional):');
-          console.error('   reporter: [');
-          console.error('     [\'@testlens/playwright-reporter\', {');
-          console.error('       caCertificate: \'/path/to/your/ca-certificate.pem\'');
-          console.error('     }]');
-          console.error('   ]');
-          console.error('');
-          console.error('3. Contact your network administrator if you\'re behind a corporate proxy');
-          console.error('   that uses a custom CA certificate.');
-          console.error('');
-          console.error('⚠️  WARNING: Setting NODE_TLS_REJECT_UNAUTHORIZED=0 disables SSL verification');
-          console.error('   and is insecure. Only use this as a last resort in development.');
-          console.error('');
-          console.error('='.repeat(80));
-          console.error('');
-        } 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
-          });
-        }
+      } 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
@@ -1166,37 +991,58 @@ export class TestLensReporter implements Reporter {
           }
 
           // Upload to S3 first (pass DB ID if available for faster lookup)
-          const s3Data = await this.uploadArtifactToS3(attachment.path, testId, fileName, testCaseDbId);
-          
-          // Skip if upload failed or file was too large
-          if (!s3Data) {
-            console.log(`⏭️  [Test: ${testId.substring(0, 8)}...] 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
-          };
+          // Create upload promise that we can track
+          const uploadPromise = Promise.resolve().then(async () => {
+            try {
+              if (!attachment.path) {
+                console.log(`⏭️  [Test: ${testId.substring(0, 8)}...] Skipping artifact ${attachment.name} - no file path`);
+                return;
+              }
+              
+              const s3Data = await this.uploadArtifactToS3(attachment.path, testId, fileName, testCaseDbId);
+              
+              // Skip if upload failed or file was too large
+              if (!s3Data) {
+                console.log(`⏭️  [Test: ${testId.substring(0, 8)}...] Skipping artifact ${attachment.name} - upload failed or file too large`);
+                return;
+              }
+              
+              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
+              // Send artifact data to API
+              await this.sendToApi({
+                type: 'artifact',
+                runId: this.runId,
+                timestamp: new Date().toISOString(),
+                artifact: artifactData
+              });
+              
+              console.log(`📎 [Test: ${testId.substring(0, 8)}...] Processed artifact: ${fileName}`);
+            } catch (error) {
+              console.error(`❌ [Test: ${testId.substring(0, 8)}...] Failed to process artifact ${attachment.name}:`, (error as Error).message);
+            }
           });
           
-          console.log(`📎 [Test: ${testId.substring(0, 8)}...] Processed artifact: ${fileName}`);
+          // Track this upload and ensure cleanup on completion
+          this.pendingUploads.add(uploadPromise);
+          uploadPromise.finally(() => {
+            this.pendingUploads.delete(uploadPromise);
+          });
+          
+          // Don't await here - let uploads happen in parallel
+          // They will be awaited in onEnd
         } catch (error) {
-          console.error(`❌ [Test: ${testId.substring(0, 8)}...] Failed to process artifact ${attachment.name}:`, (error as Error).message);
+          console.error(`❌ [Test: ${testId.substring(0, 8)}...] Failed to setup artifact upload ${attachment.name}:`, (error as Error).message);
         }
       }
     }
@@ -1217,8 +1063,13 @@ export class TestLensReporter implements Reporter {
       }));
       
       // Send to dedicated spec code blocks API endpoint
-      const baseUrl = this.config.apiEndpoint.replace('/webhook/playwright', '');
-      const specEndpoint = `${baseUrl}/webhook/playwright/spec-code-blocks`;
+      // Extract base URL - handle both full and partial endpoint patterns
+      let baseUrl = this.config.apiEndpoint.replace('/api/v1/webhook/playwright', '');
+      if (baseUrl === this.config.apiEndpoint) {
+        // Fallback: try alternative pattern if main pattern didn't match
+        baseUrl = this.config.apiEndpoint.replace('/webhook/playwright', '');
+      }
+      const specEndpoint = `${baseUrl}/api/v1/webhook/playwright/spec-code-blocks`;
       
       await this.axiosInstance.post(specEndpoint, {
         filePath: path.relative(process.cwd(), specPath),
@@ -1236,58 +1087,7 @@ export class TestLensReporter implements Reporter {
         return;
       }
       
-      // Check for SSL certificate errors
-      const isSslError = error?.code === 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY' || 
-                        error?.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE' ||
-                        error?.code === 'CERT_HAS_EXPIRED' ||
-                        error?.code === 'SELF_SIGNED_CERT_IN_CHAIN' ||
-                        error?.message?.includes('certificate') ||
-                        error?.message?.includes('SSL') ||
-                        error?.message?.includes('TLS');
-
-      if (isSslError) {
-        console.error('\n' + '='.repeat(80));
-        console.error('❌ SSL Certificate Error');
-        console.error('='.repeat(80));
-        console.error('');
-        console.error('Failed to send spec code blocks due to SSL certificate issue.');
-        console.error('');
-        console.error('The reporter automatically attempts to detect and use system CA certificates.');
-        console.error('If this error persists, it may indicate:');
-        console.error('  - Missing or outdated system CA certificates');
-        console.error('  - Corporate proxy with custom CA certificate');
-        console.error('  - Incomplete certificate chain from the server');
-        console.error('');
-        console.error('Error details:');
-        console.error(`  Code: ${error?.code || 'Unknown'}`);
-        console.error(`  Message: ${error?.message || 'Unknown error'}`);
-        console.error('');
-        console.error('Possible solutions:');
-        console.error('');
-        console.error('1. Update your system\'s CA certificate store:');
-        console.error('   - Windows: Update Windows root certificates via Windows Update');
-        console.error('   - macOS: Run: sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain <certificate.pem>');
-        console.error('   - Linux: Update ca-certificates package: sudo apt-get update && sudo apt-get install ca-certificates');
-        console.error('');
-        console.error('2. If you have a custom CA certificate file (e.g., from corporate proxy),');
-        console.error('   you can specify it in your config (optional):');
-        console.error('   reporter: [');
-        console.error('     [\'@testlens/playwright-reporter\', {');
-        console.error('       caCertificate: \'/path/to/your/ca-certificate.pem\'');
-        console.error('     }]');
-        console.error('   ]');
-        console.error('');
-        console.error('3. Contact your network administrator if you\'re behind a corporate proxy');
-        console.error('   that uses a custom CA certificate.');
-        console.error('');
-        console.error('⚠️  WARNING: Setting NODE_TLS_REJECT_UNAUTHORIZED=0 disables SSL verification');
-        console.error('   and is insecure. Only use this as a last resort in development.');
-        console.error('');
-        console.error('='.repeat(80));
-        console.error('');
-      } else {
-        console.error('Failed to send spec code blocks:', errorData || error?.message || 'Unknown error');
-      }
+      console.error('Failed to send spec code blocks:', errorData || error?.message || 'Unknown error');
     }
   }
 
@@ -1504,8 +1304,8 @@ export class TestLensReporter implements Reporter {
         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
-        // Use the same HTTPS agent with CA certificates for S3 uploads
-        httpsAgent: (this.axiosInstance.defaults as any).httpsAgent
+        // Don't use custom HTTPS agent for S3 uploads
+        httpsAgent: undefined
       });
 
       if (uploadResponse.status !== 200) {
@@ -1556,7 +1356,7 @@ export class TestLensReporter implements Reporter {
         
         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));
+          console.error('\n' + '='.repeat(80));
           
           if (errorData?.error === 'test_cases_limit_reached') {
             console.error('❌ TESTLENS ERROR: Test Cases Limit Reached');
@@ -1637,26 +1437,8 @@ export class TestLensReporter implements Reporter {
     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, '');
-  }
+  // Note: S3 key generation and sanitization are handled server-side
+  // generateS3Key() and sanitizeForS3() methods removed as they were not used
 
   private getFileSize(filePath: string): number {
     try {
@@ -1670,3 +1452,4 @@ export class TestLensReporter implements Reporter {
 }
 
 export default TestLensReporter;
+