dashcam 1.4.2-beta → 1.4.5-beta

package/PERFORMANCE_TRACKING.md

@@ -0,0 +1,139 @@
+# Performance Tracking
+
+The Dashcam CLI now includes comprehensive performance tracking during recordings. This feature monitors CPU and memory usage throughout the recording session and includes the data in the log files.
+
+## What's Tracked
+
+### 1. Dashcam Process Metrics
+- **CPU Usage**: Percentage of CPU used by the Dashcam process
+- **Memory Usage**: Memory consumed by the Dashcam process in bytes and MB
+- **Process Info**: PID, parent PID, CPU time, elapsed time
+
+### 2. System-Wide Metrics
+- **Total Memory**: System total and free memory
+- **Memory Usage Percentage**: Overall system memory utilization
+- **CPU Count**: Number of CPU cores available
+
+### 3. Top Processes
+- **Top 10 by CPU**: The most CPU-intensive processes running on the system
+- **Top 10 by Memory**: The most memory-intensive processes running on the system
+- **Process Details**: For each top process, tracks:
+  - Process name
+  - PID
+  - CPU usage percentage
+  - Memory usage in bytes
+  - Parent process ID
+  - CPU time and elapsed time
+
+## Sampling Frequency
+
+Performance metrics are sampled every **1 second** (1000ms) during the recording session.
+
+## Output Format
+
+Performance data is included in the recording result with the following structure:
+
+```javascript
+{
+  performance: {
+    samples: [
+      {
+        timestamp: 1700000000000,
+        elapsedMs: 1000,
+        system: {
+          totalMemory: 17179869184,
+          freeMemory: 8589934592,
+          usedMemory: 8589934592,
+          memoryUsagePercent: 50.0,
+          cpuCount: 8
+        },
+        process: {
+          cpu: 15.5,
+          memory: 134217728,
+          pid: 12345,
+          ppid: 1,
+          ctime: 5000,
+          elapsed: 10000
+        },
+        topProcesses: [
+          {
+            pid: 54321,
+            name: "ffmpeg",
+            cpu: 85.2,
+            memory: 268435456,
+            ppid: 12345,
+            ctime: 8500,
+            elapsed: 10000
+          },
+          // ... up to 10 processes
+        ],
+        totalProcesses: 342
+      }
+      // ... one sample per second
+    ],
+    summary: {
+      durationMs: 10000,
+      sampleCount: 10,
+      monitorInterval: 1000,
+      avgProcessCPU: 12.3,
+      maxProcessCPU: 18.7,
+      avgProcessMemoryBytes: 134217728,
+      avgProcessMemoryMB: 128.0,
+      maxProcessMemoryBytes: 201326592,
+      maxProcessMemoryMB: 192.0,
+      avgSystemMemoryUsagePercent: 52.5,
+      maxSystemMemoryUsagePercent: 55.3,
+      totalSystemMemoryBytes: 17179869184,
+      totalSystemMemoryGB: 16.0
+    }
+  }
+}
+```
+
+## Summary Statistics
+
+The performance tracker calculates summary statistics including:
+- **Average and Max Process CPU**: How much CPU the Dashcam process used
+- **Average and Max Process Memory**: Memory consumed by the Dashcam process
+- **Average and Max System Memory Usage**: Overall system memory pressure
+- **Total Duration**: How long the tracking ran
+- **Sample Count**: Number of samples collected
+
+## Logging
+
+Performance data is logged to the standard Dashcam log files:
+- `~/.dashcam/logs/combined.log` - All log levels including performance samples
+- `~/.dashcam/logs/debug.log` - Debug-level information
+- Console output when running with `--verbose` flag
+
+## Testing
+
+Run the performance tracking test:
+
+```bash
+node test-performance-tracking.js
+```
+
+This will:
+1. Start a 10-second recording
+2. Collect performance samples every second
+3. Display detailed performance statistics
+4. Show the top 10 processes at the end of the recording
+
+## Use Cases
+
+Performance tracking helps with:
+- **Debugging Performance Issues**: Identify when recordings are resource-intensive
+- **Optimization**: Track the impact of code changes on resource usage
+- **System Monitoring**: Understand what other processes are running during recordings
+- **Troubleshooting**: Correlate performance issues with specific applications or system states
+- **Capacity Planning**: Understand resource requirements for different recording scenarios
+
+## Implementation Details
+
+The performance tracker uses:
+- `pidusage` - For detailed per-process CPU and memory statistics
+- `ps-list` - For listing all system processes
+- `os` module - For system-wide memory and CPU information
+
+The tracker runs in parallel with the recording and has minimal overhead (~1% CPU on average).

package/bin/dashcam-background.js

@@ -161,11 +161,66 @@ async function runBackgroundRecording() {
       }
       isShuttingDown = true;
       
-      logger.info(`Received ${signal}, background process will be killed`);
-      console.log('[Background] Received stop signal, process will be terminated...');
+      logger.info(`Received ${signal}, stopping recording and collecting data`);
+      console.log('[Background] Received stop signal, stopping recording...');
+      
+      try {
+        // Stop the recording properly to collect all tracking data
+        const { stopRecording } = await import('../lib/recorder.js');
+        const result = await stopRecording();
+        
+        logger.info('Recording stopped successfully', {
+          outputPath: result.outputPath,
+          duration: result.duration,
+          performanceSamples: result.performance?.summary?.sampleCount || 0
+        });
+        
+        // Write the complete result to file for the stop command to read
+        const RECORDING_RESULT_FILE = path.join(PROCESS_DIR, 'recording-result.json');
+        fs.writeFileSync(RECORDING_RESULT_FILE, JSON.stringify({
+          ...result,
+          timestamp: Date.now()
+        }, null, 2));
+        
+        logger.info('Saved recording result to file', { 
+          path: RECORDING_RESULT_FILE,
+          performanceSamples: result.performance?.summary?.sampleCount || 0 
+        });
+        
+        // Update status to indicate recording is complete
+        writeStatus({
+          isRecording: false,
+          completedAt: Date.now(),
+          outputPath: result.outputPath,
+          duration: result.duration
+        });
+        
+      } catch (error) {
+        logger.error('Error stopping recording during shutdown', { error: error.message });
+        
+        // Still try to kill child processes
+        try {
+          const { exec } = await import('child_process');
+          const platform = process.platform;
+          
+          if (platform === 'darwin' || platform === 'linux') {
+            exec(`pkill -P ${process.pid}`, (error) => {
+              if (error && error.code !== 1) {
+                logger.warn('Failed to kill child processes', { error: error.message });
+              }
+            });
+          } else if (platform === 'win32') {
+            exec(`taskkill /F /T /PID ${process.pid}`, (error) => {
+              if (error) {
+                logger.warn('Failed to kill child processes on Windows', { error: error.message });
+              }
+            });
+          }
+        } catch (cleanupError) {
+          logger.error('Error during cleanup', { error: cleanupError.message });
+        }
+      }
       
-      // Don't try to stop recording here - the main process will handle cleanup
-      // after killing this process. Just exit.
       logger.info('Background process exiting');
       process.exit(0);
     };

package/bin/dashcam.js

@@ -25,6 +25,57 @@ if (!fs.existsSync(APP.recordingsDir)) {
   fs.mkdirSync(APP.recordingsDir, { recursive: true });
 }
 
+// Handle graceful shutdown on terminal close or process termination
+// This prevents orphaned FFmpeg processes and ensures clean exit
+let isShuttingDown = false;
+
+async function gracefulShutdown(signal) {
+  if (isShuttingDown) {
+    logger.debug('Shutdown already in progress, ignoring additional signal', { signal });
+    return;
+  }
+  
+  isShuttingDown = true;
+  logger.info('Received shutdown signal, cleaning up...', { signal });
+  
+  try {
+    // Check if there's an active recording and stop it
+    if (processManager.isRecordingActive()) {
+      logger.info('Stopping active recording before exit...');
+      await processManager.stopActiveRecording().catch(err => {
+        logger.warn('Failed to stop recording during shutdown', { error: err.message });
+      });
+    }
+    
+    logger.info('Cleanup complete, exiting gracefully');
+    process.exit(0);
+  } catch (error) {
+    logger.error('Error during graceful shutdown', { error: error.message });
+    process.exit(1);
+  }
+}
+
+// Register signal handlers for graceful shutdown
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGHUP', () => gracefulShutdown('SIGHUP'));
+
+// Handle uncaught errors to prevent crashes
+process.on('uncaughtException', (error) => {
+  logger.error('Uncaught exception', { 
+    error: error.message, 
+    stack: error.stack 
+  });
+  gracefulShutdown('uncaughtException');
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('Unhandled promise rejection', { 
+    reason: reason instanceof Error ? reason.message : reason,
+    stack: reason instanceof Error ? reason.stack : undefined
+  });
+});
+
 program
   .name('dashcam')
   .description('Capture the steps to reproduce every bug.')
@@ -469,6 +520,24 @@ program
         console.log('Recording stopped successfully');
         logger.debug('Stop result:', result);
         
+        // Try to read the recording result saved by the background process
+        // This includes performance data and other tracking information
+        const RECORDING_RESULT_FILE = path.join(os.homedir(), '.dashcam-cli', 'recording-result.json');
+        let backgroundResult = null;
+        if (fs.existsSync(RECORDING_RESULT_FILE)) {
+          try {
+            const resultData = fs.readFileSync(RECORDING_RESULT_FILE, 'utf8');
+            backgroundResult = JSON.parse(resultData);
+            logger.info('Loaded recording result from background process', {
+              outputPath: backgroundResult.outputPath,
+              duration: backgroundResult.duration,
+              performanceSamples: backgroundResult.performance?.summary?.sampleCount || 0
+            });
+          } catch (error) {
+            logger.warn('Failed to read background recording result', { error: error.message });
+          }
+        }
+        
         // Reconstruct recording data from status and fix video with FFmpeg
         console.log('Processing recording...');
         logger.debug('Reconstructing recording data from status file');
@@ -622,14 +691,33 @@ program
             const { jsonl } = await import('../lib/utilities/jsonl.js');
             const webLogs = jsonl.read(webLogsFile);
             if (webLogs && webLogs.length > 0) {
+              // Load web config to get patterns
+              const webConfigFile = path.join(process.cwd(), '.dashcam', 'web-config.json');
+              let webPatterns = ['*']; // Default to all patterns
+              if (fs.existsSync(webConfigFile)) {
+                try {
+                  const webConfig = JSON.parse(fs.readFileSync(webConfigFile, 'utf8'));
+                  // Extract all patterns from all enabled configs
+                  webPatterns = Object.values(webConfig)
+                    .filter(config => config.enabled !== false)
+                    .flatMap(config => config.patterns || []);
+                  if (webPatterns.length === 0) {
+                    webPatterns = ['*'];
+                  }
+                } catch (error) {
+                  logger.warn('Failed to load web config for patterns', { error: error.message });
+                }
+              }
+              
               logTrackingResults.push({
                 type: 'web',
                 name: 'Web Logs',
                 fileLocation: webLogsFile,
                 count: webLogs.length,
-                trimmedFileLocation: webLogsFile
+                trimmedFileLocation: webLogsFile,
+                patterns: webPatterns // Include patterns for filtering
               });
-              logger.info('Found web logs', { count: webLogs.length, file: webLogsFile });
+              logger.info('Found web logs', { count: webLogs.length, file: webLogsFile, patterns: webPatterns });
             }
           }
           
@@ -641,6 +729,87 @@ program
           logger.warn('Failed to collect log tracking results', { error: error.message });
         }
         
+        // Read performance data from file if available
+        let performanceData = null;
+        try {
+          const performanceFile = path.join(recordingDir, 'performance.jsonl');
+          if (fs.existsSync(performanceFile)) {
+            logger.info('Found performance file, reading data', { file: performanceFile });
+            
+            // Read the file directly and parse samples
+            const fileContent = fs.readFileSync(performanceFile, 'utf8');
+            const lines = fileContent.trim().split('\n').filter(line => line.length > 0);
+            const samples = lines.map(line => JSON.parse(line));
+            
+            logger.info('Parsed performance samples from file', { sampleCount: samples.length });
+            
+            // Calculate summary statistics
+            if (samples.length > 0) {
+              const firstSample = samples[0];
+              const lastSample = samples[samples.length - 1];
+              
+              let totalProcessCPU = 0;
+              let totalProcessMemory = 0;
+              let totalSystemMemoryUsage = 0;
+              let maxProcessCPU = 0;
+              let maxProcessMemory = 0;
+              let maxSystemMemoryUsage = 0;
+              
+              samples.forEach(sample => {
+                const processCPU = sample.process?.cpu || 0;
+                const processMemory = sample.process?.memory || 0;
+                const systemMemoryUsage = sample.system?.memoryUsagePercent || 0;
+                
+                totalProcessCPU += processCPU;
+                totalProcessMemory += processMemory;
+                totalSystemMemoryUsage += systemMemoryUsage;
+                
+                maxProcessCPU = Math.max(maxProcessCPU, processCPU);
+                maxProcessMemory = Math.max(maxProcessMemory, processMemory);
+                maxSystemMemoryUsage = Math.max(maxSystemMemoryUsage, systemMemoryUsage);
+              });
+              
+              const count = samples.length;
+              const finalSample = samples[samples.length - 1];
+              const totalBytesReceived = finalSample.network?.bytesReceived || 0;
+              const totalBytesSent = finalSample.network?.bytesSent || 0;
+              
+              const summary = {
+                durationMs: lastSample.timestamp - firstSample.timestamp,
+                sampleCount: count,
+                monitorInterval: 5000,
+                avgProcessCPU: totalProcessCPU / count,
+                maxProcessCPU,
+                avgProcessMemoryBytes: totalProcessMemory / count,
+                avgProcessMemoryMB: (totalProcessMemory / count) / (1024 * 1024),
+                maxProcessMemoryBytes: maxProcessMemory,
+                maxProcessMemoryMB: maxProcessMemory / (1024 * 1024),
+                avgSystemMemoryUsagePercent: totalSystemMemoryUsage / count,
+                maxSystemMemoryUsagePercent: maxSystemMemoryUsage,
+                totalSystemMemoryBytes: firstSample.system?.totalMemory || 0,
+                totalSystemMemoryGB: (firstSample.system?.totalMemory || 0) / (1024 * 1024 * 1024),
+                totalBytesReceived,
+                totalBytesSent,
+                totalMBReceived: totalBytesReceived / (1024 * 1024),
+                totalMBSent: totalBytesSent / (1024 * 1024)
+              };
+              
+              performanceData = { samples, summary };
+              
+              logger.info('Calculated performance summary', {
+                sampleCount: summary.sampleCount,
+                avgCPU: summary.avgProcessCPU.toFixed(1),
+                maxCPU: summary.maxProcessCPU.toFixed(1),
+                avgMemoryMB: summary.avgProcessMemoryMB.toFixed(1)
+              });
+            }
+          } else {
+            logger.debug('No performance file found', { expectedPath: performanceFile });
+          }
+        } catch (error) {
+          logger.warn('Failed to load performance data', { error: error.message, stack: error.stack });
+        }
+        
         // The recording is on disk and can be uploaded with full metadata
         const recordingResult = {
           outputPath,
@@ -649,14 +818,22 @@ program
           duration: result.duration,
           fileSize: fs.statSync(outputPath).size,
           clientStartDate: activeStatus.startTime,
-          apps: appTrackingResults.apps,
-          icons: appTrackingResults.icons,
-          logs: logTrackingResults,
+          apps: backgroundResult?.apps || appTrackingResults.apps,
+          icons: backgroundResult?.icons || appTrackingResults.icons,
+          logs: backgroundResult?.logs || logTrackingResults,
+          performance: performanceData || backgroundResult?.performance || null, // Prefer file data, fallback to background result
           title: activeStatus?.options?.title,
           description: activeStatus?.options?.description,
           project: activeStatus?.options?.project
         };
         
+        logger.info('Recording result prepared for upload', {
+          hasPerformanceData: !!recordingResult.performance,
+          performanceSamples: recordingResult.performance?.summary?.sampleCount || 0,
+          avgCPU: recordingResult.performance?.summary?.avgProcessCPU?.toFixed(1) || 'N/A',
+          maxCPU: recordingResult.performance?.summary?.maxProcessCPU?.toFixed(1) || 'N/A'
+        });
+        
         if (!recordingResult || !recordingResult.outputPath) {
           console.error('Failed to process recording');
           logger.error('No recording result', { recordingResult });
@@ -676,6 +853,7 @@ program
             apps: recordingResult.apps,
             icons: recordingResult.icons,
             logs: recordingResult.logs,
+            performance: recordingResult.performance, // Include performance data
             gifPath: recordingResult.gifPath,
             snapshotPath: recordingResult.snapshotPath
           });
@@ -683,8 +861,19 @@ program
           console.log('Watch your recording:', uploadResult.shareLink);
           logger.info('Upload succeeded');
           
-          // Clean up the result file
+          // Clean up the result file and recording result file
           processManager.cleanup();
+          
+          // Also clean up recording result file from background process
+          const RECORDING_RESULT_FILE = path.join(os.homedir(), '.dashcam-cli', 'recording-result.json');
+          if (fs.existsSync(RECORDING_RESULT_FILE)) {
+            try {
+              fs.unlinkSync(RECORDING_RESULT_FILE);
+              logger.debug('Cleaned up recording result file');
+            } catch (error) {
+              logger.warn('Failed to clean up recording result file', { error: error.message });
+            }
+          }
         } catch (uploadError) {
           console.error('Upload failed:', uploadError.message);
           logger.error('Upload error details:', {
@@ -719,6 +908,7 @@ program
   .option('--remove <id>', 'Remove a log tracker by ID')
   .option('--list', 'List all configured log trackers')
   .option('--status', 'Show log tracking status')
+  .option('--view [directory]', 'View logs from recording directory (defaults to most recent in /tmp/dashcam/recordings)')
   .option('--name <name>', 'Name for the log tracker (required with --add)')
   .option('--type <type>', 'Type of tracker: "web" or "file" (required with --add)')
   .option('--pattern <pattern>', 'Pattern to track (can be used multiple times)', (value, previous) => {
@@ -812,6 +1002,16 @@ program
         console.log(`  File trackers: ${status.cliFilesCount}`);
         console.log(`  Web trackers: ${status.webAppsCount}`);
         console.log(`  Total recent events: ${status.totalEvents}`);
+        console.log(`  Web daemon running: ${status.webDaemonRunning ? 'Yes' : 'No'}`);
+        
+        // Show WebSocket server info
+        const { server } = await import('../lib/websocket/server.js');
+        if (server.isListening.value) {
+          console.log(`  WebSocket server: Listening on port ${server.port}`);
+          console.log(`  WebSocket clients: ${server._socket?.clients?.size || 0} connected`);
+        } else {
+          console.log(`  WebSocket server: Not listening`);
+        }
         
         if (status.fileTrackerStats.length > 0) {
           console.log('\n  File tracker activity (last minute):');
@@ -819,13 +1019,127 @@ program
             console.log(`    ${stat.filePath}: ${stat.count} events`);
           });
         }
+        
+        if (status.webApps.length > 0) {
+          console.log('\n  Web tracker patterns:');
+          status.webApps.forEach(app => {
+            console.log(`    ${app.name}: ${app.patterns.join(', ')}`);
+          });
+        }
+      } else if (options.view !== undefined) {
+        // View logs from a recording directory
+        const { jsonl } = await import('../lib/utilities/jsonl.js');
+        
+        let targetDir = options.view;
+        
+        // If no directory specified, find the most recent recording directory
+        if (!targetDir || targetDir === true) {
+          const recordingsDir = path.join(os.tmpdir(), 'dashcam', 'recordings');
+          if (!fs.existsSync(recordingsDir)) {
+            console.error('No recordings directory found at:', recordingsDir);
+            process.exit(1);
+          }
+          
+          const entries = fs.readdirSync(recordingsDir, { withFileTypes: true });
+          const dirs = entries
+            .filter(entry => entry.isDirectory())
+            .map(entry => ({
+              name: entry.name,
+              path: path.join(recordingsDir, entry.name),
+              mtime: fs.statSync(path.join(recordingsDir, entry.name)).mtime
+            }))
+            .sort((a, b) => b.mtime - a.mtime);
+          
+          if (dirs.length === 0) {
+            console.error('No recording directories found in:', recordingsDir);
+            process.exit(1);
+          }
+          
+          targetDir = dirs[0].path;
+          console.log('Viewing logs from most recent recording:', path.basename(targetDir));
+        } else if (!fs.existsSync(targetDir)) {
+          console.error('Directory does not exist:', targetDir);
+          process.exit(1);
+        }
+        
+        console.log('Directory:', targetDir);
+        console.log('');
+        
+        // Check for CLI logs
+        const cliLogsFile = path.join(targetDir, 'dashcam_logs_cli.jsonl');
+        if (fs.existsSync(cliLogsFile)) {
+          const cliLogs = jsonl.read(cliLogsFile);
+          if (cliLogs && cliLogs.length > 0) {
+            console.log(`📄 CLI Logs (${cliLogs.length} events):`);
+            cliLogs.slice(0, 50).forEach((log, index) => {
+              const timeSeconds = ((log.time || 0) / 1000).toFixed(2);
+              const logFile = log.logFile || 'unknown';
+              const content = (log.line || log.content || '').substring(0, 100);
+              console.log(`  [${timeSeconds}s] ${logFile}: ${content}`);
+            });
+            if (cliLogs.length > 50) {
+              console.log(`  ... and ${cliLogs.length - 50} more events`);
+            }
+            console.log('');
+          }
+        } else {
+          console.log('📄 CLI Logs: No logs found');
+          console.log('');
+        }
+        
+        // Check for web logs
+        const webLogsFile = path.join(targetDir, 'dashcam_logs_web_events.jsonl');
+        if (fs.existsSync(webLogsFile)) {
+          const webLogs = jsonl.read(webLogsFile);
+          if (webLogs && webLogs.length > 0) {
+            console.log(`🌐 Web Logs (${webLogs.length} events):`);
+            
+            // Group by event type
+            const eventTypes = {};
+            webLogs.forEach(log => {
+              eventTypes[log.type] = (eventTypes[log.type] || 0) + 1;
+            });
+            
+            console.log('  Event types:');
+            Object.entries(eventTypes).forEach(([type, count]) => {
+              console.log(`    ${type}: ${count}`);
+            });
+            console.log('');
+            
+            // Show first 20 events
+            console.log('  Recent events:');
+            webLogs.slice(0, 20).forEach((log, index) => {
+              const timeSeconds = ((log.time || 0) / 1000).toFixed(2);
+              const type = log.type || 'unknown';
+              
+              if (type === 'LOG_EVENT' || type === 'LOG_ERROR') {
+                const message = log.payload?.message || '';
+                console.log(`  [${timeSeconds}s] ${type}: ${message.substring(0, 80)}`);
+              } else if (type.startsWith('NETWORK_')) {
+                const url = log.payload?.url || '';
+                console.log(`  [${timeSeconds}s] ${type}: ${url.substring(0, 80)}`);
+              } else {
+                console.log(`  [${timeSeconds}s] ${type}`);
+              }
+            });
+            if (webLogs.length > 20) {
+              console.log(`  ... and ${webLogs.length - 20} more events`);
+            }
+            console.log('');
+          }
+        } else {
+          console.log('🌐 Web Logs: No logs found');
+          console.log('');
+        }
       } else {
-        console.log('Please specify an action: --add, --remove, --list, or --status');
+        console.log('Please specify an action: --add, --remove, --list, --status, or --view');
         console.log('\nExamples:');
         console.log('  dashcam logs --add --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"');
         console.log('  dashcam logs --add --name=app-logs --type=file --file=/var/log/app.log');
         console.log('  dashcam logs --list');
         console.log('  dashcam logs --status');
+        console.log('  dashcam logs --view                    # View logs from most recent recording');
+        console.log('  dashcam logs --view /path/to/recording # View logs from specific directory');
         console.log('\nUse "dashcam logs --help" for more information');
       }
       

package/lib/auth.js

@@ -1,5 +1,5 @@
 import got from 'got';
-import { auth0Config } from './config.js';
+import { auth0Config, API_ENDPOINT } from './config.js';
 import { logger, logFunctionCall } from './logger.js';
 import { Store } from './store.js';
 
@@ -14,11 +14,12 @@ const auth = {
       logger.info('Authenticating with API key');
       logger.verbose('Starting API key exchange', {
         apiKeyLength: apiKey?.length,
-        hasApiKey: !!apiKey
+        hasApiKey: !!apiKey,
+        apiEndpoint: API_ENDPOINT
       });
       
       // Exchange API key for token
-      const { token } = await got.post('https://testdriver-api.onrender.com/auth/exchange-api-key', {
+      const { token } = await got.post(`${API_ENDPOINT}/auth/exchange-api-key`, {
         json: { apiKey },
         timeout: 30000 // 30 second timeout
       }).json();
@@ -34,7 +35,7 @@ const auth = {
 
       // Get user info to verify the token works
       logger.debug('Fetching user information to validate token...');
-      const user = await got.get('https://testdriver-api.onrender.com/api/v1/whoami', {
+      const user = await got.get(`${API_ENDPOINT}/api/v1/whoami`, {
         headers: {
           Authorization: `Bearer ${token}`
         },
@@ -105,7 +106,7 @@ const auth = {
     const token = await this.getToken();
     
     try {
-      const response = await got.get('https://testdriver-api.onrender.com/api/v1/projects', {
+      const response = await got.get(`${API_ENDPOINT}/api/v1/projects`, {
         headers: {
           Authorization: `Bearer ${token}`
         },
@@ -160,7 +161,7 @@ const auth = {
       requestBody.project = replayData.project;
     }
     
-    const response = await got.post('https://testdriver-api.onrender.com/api/v1/replay/upload', {
+    const response = await got.post(`${API_ENDPOINT}/api/v1/replay/upload`, {
       headers: {
         Authorization: `Bearer ${token}`
       },
@@ -188,7 +189,7 @@ const auth = {
     const token = await this.getToken();
     
     try {
-      const response = await got.post('https://testdriver-api.onrender.com/api/v1/logs', {
+      const response = await got.post(`${API_ENDPOINT}/api/v1/logs`, {
         headers: {
           Authorization: `Bearer ${token}`
         },