dashcam 1.4.3-beta → 1.4.5-beta.0

package/lib/topProcesses.js

@@ -0,0 +1,128 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
+import { logger } from './logger.js';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Parse ps output format: "  PID %CPU %MEM COMMAND"
+ */
+function parsePsOutput(stdout, limit) {
+  const lines = stdout.trim().split('\n');
+  // Skip header line
+  return lines.slice(1, 1 + limit).map(line => {
+    const parts = line.trim().split(/\s+/, 4);
+    return {
+      pid: Number(parts[0]),
+      cpu: Number(parts[1]),
+      mem: Number(parts[2]),
+      name: parts[3] || ''
+    };
+  });
+}
+
+/**
+ * Get top processes on Unix-like systems (Linux, macOS)
+ */
+async function getTopProcessesUnix(limit = 10) {
+  try {
+    let stdout;
+    
+    if (os.platform() === 'darwin') {
+      // macOS uses BSD ps - different syntax, no --sort option
+      // Use -r flag to sort by CPU usage
+      const result = await execFileAsync('ps', [
+        '-Arco',
+        'pid,pcpu,pmem,comm'
+      ], { encoding: 'utf8' });
+      stdout = result.stdout;
+    } else {
+      // Linux uses GNU ps - supports --sort
+      const result = await execFileAsync('ps', [
+        '-eo',
+        'pid,pcpu,pmem,comm',
+        '--sort=-pcpu'
+      ], { encoding: 'utf8' });
+      stdout = result.stdout;
+    }
+    
+    return parsePsOutput(stdout, limit);
+  } catch (error) {
+    logger.warn('Failed to get top processes on Unix', { error: error.message });
+    return [];
+  }
+}
+
+/**
+ * Parse PowerShell JSON output for Windows processes
+ */
+function parsePsWinJson(stdout, limit) {
+  let arr;
+  try {
+    arr = JSON.parse(stdout);
+  } catch (e) {
+    logger.warn('Failed to parse PowerShell JSON output', { error: e.message });
+    return [];
+  }
+  
+  if (!Array.isArray(arr)) {
+    arr = [arr];
+  }
+
+  // Some fields may be undefined if CPU hasn't updated yet
+  arr.sort((a, b) => (b.CPU || 0) - (a.CPU || 0));
+
+  return arr.slice(0, limit).map(p => ({
+    pid: p.Id,
+    cpu: p.CPU || 0,              // total CPU seconds
+    memBytes: p.WS || 0,          // working set in bytes
+    name: p.ProcessName || ''
+  }));
+}
+
+/**
+ * Get top processes on Windows using PowerShell
+ */
+async function getTopProcessesWindows(limit = 10) {
+  try {
+    // Use PowerShell to get process info and convert to JSON
+    // NOTE: PowerShell startup is slower but more reliable than WMI
+    const psCmd = [
+      'Get-Process | ',
+      'Select-Object Id,CPU,WS,ProcessName | ',
+      'ConvertTo-Json'
+    ].join('');
+
+    const { stdout } = await execFileAsync('powershell.exe', [
+      '-NoLogo',
+      '-NoProfile',
+      '-NonInteractive',
+      '-Command',
+      psCmd
+    ], { encoding: 'utf8' });
+
+    return parsePsWinJson(stdout, limit);
+  } catch (error) {
+    logger.warn('Failed to get top processes on Windows', { error: error.message });
+    return [];
+  }
+}
+
+/**
+ * Get top processes by CPU usage (cross-platform)
+ * @param {number} limit - Number of top processes to return (default: 10)
+ * @returns {Promise<Array>} Array of process objects with pid, cpu, mem/memBytes, and name
+ */
+export async function getTopProcesses(limit = 10) {
+  const platform = os.platform();
+  
+  logger.debug('Getting top processes', { platform, limit });
+  
+  if (platform === 'win32') {
+    return getTopProcessesWindows(limit);
+  }
+  
+  // Linux, macOS, and other Unix-like systems
+  return getTopProcessesUnix(limit);
+}

package/lib/uploader.js

@@ -6,6 +6,7 @@ import path from 'path';
 import { auth } from './auth.js';
 import got from 'got';
 import { getSystemInfo } from './systemInfo.js';
+import { API_ENDPOINT } from './config.js';
 
 class Uploader {
   constructor() {
@@ -250,7 +251,8 @@ export async function upload(filePath, metadata = {}) {
     apps: metadata.apps && metadata.apps.length > 0 ? metadata.apps : ['Screen Recording'], // Use tracked apps or fallback
     title: metadata.title || defaultTitle,
     system: systemInfo, // Include system information
-    clientStartDate: metadata.clientStartDate || Date.now() // Use actual recording start time
+    clientStartDate: metadata.clientStartDate || Date.now(), // Use actual recording start time
+    performance: metadata.performance // Include performance tracking data
   };
 
   // Add project if we have one
@@ -262,18 +264,28 @@ export async function upload(filePath, metadata = {}) {
     replayConfig.description = metadata.description;
   }
 
-  logger.verbose('Creating replay with config', replayConfig);
+  logger.verbose('Creating replay with config', {
+    ...replayConfig,
+    performanceSamples: replayConfig.performance?.samples?.length || 0,
+    performanceSummary: replayConfig.performance?.summary ? 'included' : 'none'
+  });
 
   console.log('Creating replay on server...');
-  logger.info('Creating replay', replayConfig);
+  logger.info('Creating replay', {
+    title: replayConfig.title,
+    duration: replayConfig.duration,
+    apps: replayConfig.apps,
+    hasPerformanceData: !!replayConfig.performance,
+    performanceSamples: replayConfig.performance?.samples?.length || 0
+  });
 
   // Create the replay first
   const token = await auth.getToken();
   
   let newReplay;
   try {
-    logger.debug('Sending replay creation request...');
-    newReplay = await got.post('https://testdriver-api.onrender.com/api/v1/replay', {
+    logger.debug('Sending replay creation request...', { apiEndpoint: API_ENDPOINT });
+    newReplay = await got.post(`${API_ENDPOINT}/api/v1/replay`, {
       headers: {
         Authorization: `Bearer ${token}`
       },
@@ -459,7 +471,7 @@ export async function upload(filePath, metadata = {}) {
   console.log('Publishing replay...');
   
   try {
-    await got.post('https://testdriver-api.onrender.com/api/v1/replay/publish', {
+    await got.post(`${API_ENDPOINT}/api/v1/replay/publish`, {
       headers: {
         Authorization: `Bearer ${token}`
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashcam",
-  "version": "1.4.3-beta",
+  "version": "1.4.5-beta.0",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/dashcam.js",
   "bin": {
@@ -47,6 +47,7 @@
     "mask-sensitive-data": "^0.11.5",
     "node-fetch": "^2.7.0",
     "open": "^9.1.0",
+    "pidusage": "^3.0.2",
     "systeminformation": "^5.18.15",
     "tail": "^2.2.6",
     "winston": "^3.11.0",

package/test-perf-tracker.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import { PerformanceTracker } from './lib/performanceTracker.js';
+import { logger, setVerbose } from './lib/logger.js';
+
+setVerbose(true);
+
+async function testPerformanceTracking() {
+  console.log('Testing performance tracking with top processes...\n');
+  
+  const tracker = new PerformanceTracker();
+  
+  // Start tracking
+  tracker.start();
+  console.log('Started tracking...');
+  
+  // Wait for 6 seconds to get at least one sample
+  console.log('Waiting 6 seconds for sample...');
+  await new Promise(resolve => setTimeout(resolve, 6000));
+  
+  // Stop tracking
+  const result = tracker.stop();
+  
+  console.log('\n=== Performance Tracking Results ===');
+  console.log(`Total samples: ${result.samples.length}`);
+  
+  if (result.samples.length > 0) {
+    const firstSample = result.samples[0];
+    console.log('\nFirst sample keys:', Object.keys(firstSample));
+    console.log('Has topProcesses:', !!firstSample.topProcesses);
+    console.log('topProcesses count:', firstSample.topProcesses?.length || 0);
+    
+    if (firstSample.topProcesses && firstSample.topProcesses.length > 0) {
+      console.log('\nTop 3 processes:');
+      firstSample.topProcesses.slice(0, 3).forEach((proc, i) => {
+        console.log(`${i + 1}. ${proc.name} (PID: ${proc.pid})`);
+        console.log(`   CPU: ${proc.cpu.toFixed(1)}%`);
+        console.log(`   Memory: ${(proc.memory / (1024 * 1024)).toFixed(1)} MB`);
+      });
+    }
+  }
+  
+  if (result.summary) {
+    console.log('\nSummary:');
+    console.log(`  Duration: ${(result.summary.durationMs / 1000).toFixed(1)}s`);
+    console.log(`  Sample count: ${result.summary.sampleCount}`);
+    console.log(`  Avg CPU: ${result.summary.avgProcessCPU.toFixed(1)}%`);
+    console.log(`  Max CPU: ${result.summary.maxProcessCPU.toFixed(1)}%`);
+  }
+}
+
+testPerformanceTracking().catch(console.error);

package/test-performance-tracking.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+/**
+ * Test script to verify performance tracking during recording
+ */
+
+import { startRecording, stopRecording } from './lib/recorder.js';
+import { logger, setVerbose } from './lib/logger.js';
+import fs from 'fs';
+
+// Enable verbose logging
+setVerbose(true);
+
+async function testPerformanceTracking() {
+  try {
+    logger.info('Starting performance tracking test...');
+    
+    // Start recording
+    logger.info('Starting recording...');
+    const startResult = await startRecording({
+      fps: 10,
+      includeAudio: false
+    });
+    
+    logger.info('Recording started', {
+      outputPath: startResult.outputPath,
+      startTime: startResult.startTime
+    });
+    
+    // Record for 10 seconds
+    logger.info('Recording for 10 seconds...');
+    await new Promise(resolve => setTimeout(resolve, 10000));
+    
+    // Stop recording
+    logger.info('Stopping recording...');
+    const result = await stopRecording();
+    
+    logger.info('Recording stopped successfully');
+    
+    // Display performance results
+    if (result.performance) {
+      logger.info('=== Performance Tracking Results ===');
+      
+      if (result.performance.summary) {
+        const summary = result.performance.summary;
+        logger.info('Summary Statistics:');
+        logger.info(`  Duration: ${(summary.durationMs / 1000).toFixed(1)}s`);
+        logger.info(`  Sample Count: ${summary.sampleCount}`);
+        logger.info(`  Monitor Interval: ${summary.monitorInterval}ms`);
+        logger.info('');
+        logger.info('Process Metrics:');
+        logger.info(`  Average CPU: ${summary.avgProcessCPU.toFixed(1)}%`);
+        logger.info(`  Max CPU: ${summary.maxProcessCPU.toFixed(1)}%`);
+        logger.info(`  Average Memory: ${summary.avgProcessMemoryMB.toFixed(1)} MB`);
+        logger.info(`  Max Memory: ${summary.maxProcessMemoryMB.toFixed(1)} MB`);
+        logger.info('');
+        logger.info('System Metrics:');
+        logger.info(`  Average System Memory Usage: ${summary.avgSystemMemoryUsagePercent.toFixed(1)}%`);
+        logger.info(`  Max System Memory Usage: ${summary.maxSystemMemoryUsagePercent.toFixed(1)}%`);
+        logger.info(`  Total System Memory: ${summary.totalSystemMemoryGB.toFixed(2)} GB`);
+      }
+      
+      if (result.performance.samples && result.performance.samples.length > 0) {
+        logger.info('');
+        logger.info(`Collected ${result.performance.samples.length} performance samples`);
+        
+        // Show top processes from the last sample
+        const lastSample = result.performance.samples[result.performance.samples.length - 1];
+        if (lastSample.topProcesses && lastSample.topProcesses.length > 0) {
+          logger.info('');
+          logger.info('Top 10 Processes (from last sample):');
+          lastSample.topProcesses.forEach((proc, index) => {
+            logger.info(`  ${index + 1}. ${proc.name} (PID: ${proc.pid})`);
+            logger.info(`     CPU: ${proc.cpu.toFixed(1)}%, Memory: ${(proc.memory / (1024 * 1024)).toFixed(1)} MB`);
+          });
+          logger.info(`Total processes on system: ${lastSample.totalProcesses}`);
+        }
+      }
+    } else {
+      logger.warn('No performance data in result');
+    }
+    
+    // Display other results
+    logger.info('');
+    logger.info('=== Recording Results ===');
+    logger.info(`Output: ${result.outputPath}`);
+    logger.info(`Duration: ${result.duration}ms`);
+    logger.info(`File Size: ${(result.fileSize / 1024 / 1024).toFixed(2)} MB`);
+    logger.info(`Apps Tracked: ${result.apps?.length || 0}`);
+    logger.info(`Log Events: ${result.logs?.reduce((sum, log) => sum + log.count, 0) || 0}`);
+    
+    // Verify file exists
+    if (fs.existsSync(result.outputPath)) {
+      logger.info('Recording file created successfully');
+    } else {
+      logger.error('Recording file not found!');
+    }
+    
+    logger.info('Test completed successfully!');
+    
+  } catch (error) {
+    logger.error('Test failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run the test
+testPerformanceTracking();

package/test-top-processes.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { getTopProcesses } from './lib/topProcesses.js';
+import { logger, setVerbose } from './lib/logger.js';
+
+setVerbose(true);
+
+async function test() {
+  console.log('Testing getTopProcesses...\n');
+  
+  const processes = await getTopProcesses(10);
+  
+  console.log(`Found ${processes.length} processes:\n`);
+  
+  processes.forEach((proc, index) => {
+    console.log(`${index + 1}. ${proc.name} (PID: ${proc.pid})`);
+    console.log(`   CPU: ${proc.cpu}%`);
+    console.log(`   Memory: ${proc.mem || proc.memBytes}${proc.memBytes ? ' bytes' : '%'}`);
+    console.log();
+  });
+}
+
+test().catch(console.error);

package/test_workflow.sh

@@ -115,8 +115,15 @@ sleep 2
 echo ""
 echo "6. Stopping recording and uploading..."
 # Check if recording is still active
+SHARE_LINK=""
 if ./bin/dashcam.js status | grep -q "Recording in progress"; then
-  ./bin/dashcam.js stop
+  # Capture the output to extract the share link
+  STOP_OUTPUT=$(./bin/dashcam.js stop 2>&1)
+  echo "$STOP_OUTPUT"
+  
+  # Extract the share link from the output
+  SHARE_LINK=$(echo "$STOP_OUTPUT" | grep -oE "https?://[^\s]+" | head -1)
+  
   echo "✅ Recording stopped and uploaded"
 else
   echo "⚠️  Recording already completed (this is expected with background mode)"
@@ -134,6 +141,14 @@ echo ""
 echo "📊 Final Status:"
 ./bin/dashcam.js status
 
+# Open the recording in browser if we got a share link
+if [ -n "$SHARE_LINK" ]; then
+  echo ""
+  echo "🌐 Opening recording in browser..."
+  echo "Link: $SHARE_LINK"
+  open "$SHARE_LINK"
+fi
+
 echo ""
 echo "╔════════════════════════════════════════════════════════════════╗"
 echo "║                  SYNC VERIFICATION GUIDE                       ║"