dashcam 1.0.1-beta.9 → 1.0.2-beta.1

package/lib/processManager.js

@@ -160,8 +160,9 @@ class ProcessManager {
       logger.info('Stopping active recording process', { pid });
       process.kill(pid, 'SIGINT');
       
-      // Wait for the process to actually finish
-      const maxWaitTime = 30000; // 30 seconds max
+      // Wait for the process to actually finish and upload
+      // Increase timeout to allow for upload to complete
+      const maxWaitTime = 120000; // 2 minutes max to allow for upload
       const startWait = Date.now();
       
       while (this.isProcessRunning(pid) && (Date.now() - startWait) < maxWaitTime) {
@@ -174,41 +175,27 @@ class ProcessManager {
         await new Promise(resolve => setTimeout(resolve, 1000));
       }
       
-      // Call the actual recorder's stopRecording function to get complete results
+      // The background process handles stopRecording() internally via SIGINT
+      // We just need to return the basic result from the status file
       if (status) {
-        try {
-          const { stopRecording } = await import('./recorder.js');
-          const result = await stopRecording();
-          
-          logger.info('Recording stopped successfully via recorder', { 
-            outputPath: result.outputPath,
-            duration: result.duration,
-            hasLogs: result.logs?.length > 0,
-            hasApps: result.apps?.length > 0
-          });
-          
-          // Cleanup process files but preserve upload result for stop command
-          this.cleanup({ preserveResult: true });
-          
-          return result;
-        } catch (recorderError) {
-          logger.warn('Failed to stop via recorder, falling back to basic result', { error: recorderError.message });
-          
-          // Fallback to basic result if recorder fails
-          const basePath = status.outputPath.substring(0, status.outputPath.lastIndexOf('.'));
-          const result = {
-            outputPath: status.outputPath,
-            gifPath: `${basePath}.gif`,
-            snapshotPath: `${basePath}.png`,
-            duration: Date.now() - status.startTime,
-            clientStartDate: status.startTime,
-            apps: [],
-            logs: []
-          };
-          
-          this.cleanup({ preserveResult: true });
-          return result;
-        }
+        logger.info('Background recording stopped, returning status', { 
+          outputPath: status.outputPath,
+          duration: Date.now() - status.startTime
+        });
+        
+        const basePath = status.outputPath.substring(0, status.outputPath.lastIndexOf('.'));
+        const result = {
+          outputPath: status.outputPath,
+          gifPath: `${basePath}.gif`,
+          snapshotPath: `${basePath}.png`,
+          duration: Date.now() - status.startTime,
+          clientStartDate: status.startTime,
+          apps: [],
+          logs: []
+        };
+        
+        this.cleanup({ preserveResult: true });
+        return result;
       } else {
         throw new Error('No status information available for active recording');
       }

package/lib/recorder.js

@@ -8,6 +8,47 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs';
 
+/**
+ * Fix/repair a video file by re-muxing it with proper container metadata
+ * This copies streams without re-encoding and ensures proper container finalization
+ */
+async function fixVideoContainer(inputVideoPath, outputVideoPath) {
+  const logExit = logFunctionCall('fixVideoContainer', { inputVideoPath, outputVideoPath });
+  
+  try {
+    const ffmpegPath = await getFfmpegPath();
+    
+    logger.info('Re-muxing video to fix container metadata', { 
+      input: inputVideoPath, 
+      output: outputVideoPath 
+    });
+    
+    const args = [
+      '-i', inputVideoPath,
+      '-vcodec', 'copy',        // Copy video stream without re-encoding
+      '-acodec', 'copy',        // Copy audio stream without re-encoding
+      '-movflags', 'faststart', // Enable fast start for web playback
+      outputVideoPath,
+      '-y',                     // Overwrite output file
+      '-hide_banner'
+    ];
+    
+    await execa(ffmpegPath, args);
+    
+    logger.info('Successfully re-muxed video', { 
+      outputPath: outputVideoPath,
+      outputSize: fs.existsSync(outputVideoPath) ? fs.statSync(outputVideoPath).size : 0
+    });
+    
+    logExit();
+    return true;
+  } catch (error) {
+    logger.error('Failed to fix video container', { error: error.message });
+    logExit();
+    return false;
+  }
+}
+
 /**
  * Dynamically detect the primary screen capture device for the current platform
  */
@@ -116,9 +157,8 @@ const PLATFORM_CONFIG = {
     audioInput: '0',        // Default audio device if needed
     audioFormat: 'avfoundation',
     extraArgs: [
-      '-video_size', '1920x1080',  // Set explicit resolution
-      '-pixel_format', 'uyvy422',  // Use supported pixel format
-      '-r', '30'                   // Set frame rate
+      '-capture_cursor', '1',      // Capture mouse cursor
+      '-capture_mouse_clicks', '1' // Capture mouse clicks
     ]
   },
   win32: {
@@ -160,6 +200,7 @@ async function getPlatformArgs({ fps, includeAudio }) {
   });
   
   const args = [
+    '-thread_queue_size', '512',  // Increase input buffer to prevent drops
     '-f', config.inputFormat
   ];
 
@@ -170,12 +211,14 @@ async function getPlatformArgs({ fps, includeAudio }) {
 
   args.push(
     '-framerate', fps.toString(),
+    '-probesize', '50M',          // Increase probe size for better stream detection
     '-i', screenInput
   );
 
   // Add audio capture if enabled
   if (includeAudio) {
     args.push(
+      '-thread_queue_size', '512',  // Increase audio buffer too
       '-f', config.audioFormat,
       '-i', config.audioInput
     );
@@ -279,17 +322,20 @@ export async function startRecording({
   const platformArgs = await getPlatformArgs({ fps, includeAudio });
   const outputArgs = [
     '-c:v', 'libvpx-vp9',  // Use VP9 codec for better quality and compression
-    '-quality', 'realtime', // Use realtime quality preset for lower CPU usage
-    '-cpu-used', '5',      // Faster encoding (0-5, higher = faster but lower quality)
-    '-deadline', 'realtime', // Realtime encoding mode for lower latency/CPU
-    '-b:v', '2M',          // Lower bitrate to reduce CPU load (was 5M)
-    // Remove explicit pixel format to let ffmpeg handle conversion automatically
+    '-quality', 'realtime', // Use realtime quality preset for faster encoding
+    '-cpu-used', '8',       // Maximum speed (0-8, higher = faster but lower quality)
+    '-deadline', 'realtime',// Realtime encoding mode for lowest latency
+    '-b:v', '2M',           // Target bitrate
     '-r', fps.toString(),   // Ensure output framerate matches input
-    '-g', '60',            // Keyframe every 60 frames (reduced frequency)
-    // WebM options for more frequent disk writes
-    '-f', 'webm',          // Force WebM container format
-    '-flush_packets', '1', // Flush packets immediately to disk
-    '-max_muxing_queue_size', '1024' // Limit muxing queue to prevent delays
+    '-g', fps.toString(),   // Keyframe interval = 1 second (every fps frames) - ensures frequent keyframes
+    '-force_key_frames', `expr:gte(t,n_forced*1)`, // Force keyframe every 1 second
+    // WebM options for more frequent disk writes and proper stream handling
+    '-f', 'webm',           // Force WebM container format
+    '-flush_packets', '1',  // Flush packets immediately to disk - critical for short recordings
+    '-fflags', '+genpts',   // Generate presentation timestamps
+    '-avoid_negative_ts', 'make_zero', // Avoid negative timestamps
+    '-vsync', '1',          // Ensure every frame is encoded (CFR - constant frame rate)
+    '-max_muxing_queue_size', '9999' // Large queue to prevent frame drops
   ];
 
   if (includeAudio) {
@@ -465,29 +511,40 @@ export async function stopRecording() {
     duration: recordingDuration,
     durationSeconds: (recordingDuration / 1000).toFixed(1)
   });
+  
+  // Enforce minimum recording duration to prevent single-frame videos
+  const MIN_RECORDING_DURATION = 2000; // 2 seconds minimum
+  if (recordingDuration < MIN_RECORDING_DURATION) {
+    const waitTime = MIN_RECORDING_DURATION - recordingDuration;
+    logger.info(`Recording too short (${recordingDuration}ms), waiting ${waitTime}ms to ensure multiple frames`);
+    await new Promise(resolve => setTimeout(resolve, waitTime));
+  }
 
   try {
     // First try to gracefully stop FFmpeg by sending 'q'
     if (currentRecording && currentRecording.stdin) {
       logger.debug('Sending quit signal to FFmpeg...');
       currentRecording.stdin.write('q');
+      currentRecording.stdin.end(); // Close stdin to signal end
     }
 
-    // Wait for FFmpeg to finish gracefully
+    // Wait for FFmpeg to finish gracefully with realtime encoding
     const gracefulTimeout = setTimeout(() => {
       if (currentRecording && !currentRecording.killed) {
+        logger.warn('FFmpeg did not exit gracefully after 10s, sending SIGTERM...');
         // If still running, try SIGTERM
         process.kill(currentRecording.pid, 'SIGTERM');
       }
-    }, 2000);
+    }, 10000); // Wait longer for graceful shutdown
 
-    // Wait up to 5 seconds for SIGTERM to work
+    // Wait up to 20 seconds for SIGTERM to work
     const hardKillTimeout = setTimeout(() => {
       if (currentRecording && !currentRecording.killed) {
+        logger.error('FFmpeg still running after SIGTERM, using SIGKILL...');
         // If still not dead, use SIGKILL as last resort
         process.kill(currentRecording.pid, 'SIGKILL');
       }
-    }, 5000);
+    }, 20000); // Longer timeout to avoid killing prematurely
 
     // Wait for the process to fully exit
     if (currentRecording) {
@@ -498,8 +555,30 @@ export async function stopRecording() {
     clearTimeout(gracefulTimeout);
     clearTimeout(hardKillTimeout);
 
-    // Additional wait to ensure filesystem is synced - increased for reliability
-    await new Promise(resolve => setTimeout(resolve, 3000));
+    // Wait for filesystem to sync and file to be written
+    // Poll for the file to exist with content
+    logger.debug('Waiting for temp file to be written...');
+    const maxWaitTime = 10000; // Wait up to 10 seconds
+    const startWait = Date.now();
+    let tempFileReady = false;
+    
+    while (!tempFileReady && (Date.now() - startWait) < maxWaitTime) {
+      const tempFile = currentTempFile;
+      if (tempFile && fs.existsSync(tempFile)) {
+        const stats = fs.statSync(tempFile);
+        if (stats.size > 0) {
+          logger.debug('Temp file is ready', { size: stats.size });
+          tempFileReady = true;
+          break;
+        }
+      }
+      // Wait a bit before checking again
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    
+    if (!tempFileReady) {
+      logger.warn('Temp file not ready after waiting, proceeding anyway');
+    }
 
     // Read temp file path from disk (for cross-process access)
     let tempFile = currentTempFile; // Try in-memory first
@@ -547,21 +626,41 @@ export async function stopRecording() {
       path: tempFile
     });
 
-    // Since WebM is already a valid streaming format, just copy the temp file
-    // instead of trying to re-encode it which can hang
-    logger.debug('Copying temp file to final output...');
+    // Re-mux to ensure proper container metadata (duration, seekability, etc.)
+    logger.debug('Re-muxing temp file to fix container metadata...');
     
     try {
-      fs.copyFileSync(tempFile, outputPath);
-      logger.info('Successfully copied temp file to final output');
+      // First, create a temporary fixed version
+      const fixedTempFile = tempFile.replace('.webm', '-fixed.webm');
+      
+      const fixSuccess = await fixVideoContainer(tempFile, fixedTempFile);
+      
+      if (fixSuccess && fs.existsSync(fixedTempFile) && fs.statSync(fixedTempFile).size > 0) {
+        // Use the fixed version
+        logger.info('Using re-muxed version with proper container metadata');
+        fs.copyFileSync(fixedTempFile, outputPath);
+        
+        // Clean up the fixed temp file
+        try {
+          fs.unlinkSync(fixedTempFile);
+        } catch (e) {
+          logger.debug('Failed to delete fixed temp file:', e);
+        }
+      } else {
+        // Fallback: just copy the original temp file
+        logger.warn('Re-muxing failed, using original file');
+        fs.copyFileSync(tempFile, outputPath);
+      }
+      
+      logger.info('Successfully finalized recording to output');
       
       // Verify the final file exists and has content
       if (!fs.existsSync(outputPath) || fs.statSync(outputPath).size === 0) {
-        throw new Error('Final output file is empty or missing after copy');
+        throw new Error('Final output file is empty or missing after processing');
       }
       
     } catch (error) {
-      logger.error('Failed to copy temp file:', error);
+      logger.error('Failed to process temp file:', error);
       throw new Error('Failed to finalize recording: ' + error.message);
     }
 
@@ -688,3 +787,8 @@ export function getRecordingStatus() {
     outputPath
   };
 }
+
+/**
+ * Export the fix function for external use
+ */
+export { fixVideoContainer };

package/lib/systemInfo.js

@@ -0,0 +1,141 @@
+import si from 'systeminformation';
+import { logger } from './logger.js';
+
+/**
+ * Collects comprehensive system information including CPU, memory, OS, and graphics data.
+ * This matches the data format expected by the Dashcam backend (same as desktop app).
+ * 
+ * @returns {Promise<Object>} System information object
+ */
+export async function getSystemInfo() {
+  try {
+    logger.debug('Collecting system information...');
+    
+    // Collect only essential system information quickly
+    // Graphics info can be very slow, so we skip it or use a short timeout
+    const [cpu, mem, osInfo, system] = await Promise.all([
+      si.cpu(),
+      si.mem(),
+      si.osInfo(),
+      si.system()
+    ]);
+    
+    // Try to get graphics info with a very short timeout (optional)
+    let graphics = { controllers: [], displays: [] };
+    try {
+      graphics = await Promise.race([
+        si.graphics(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Graphics timeout')), 2000))
+      ]);
+    } catch (error) {
+      logger.debug('Graphics info timed out, using empty graphics data');
+    }
+
+    const systemInfo = {
+      cpu: {
+        manufacturer: cpu.manufacturer,
+        brand: cpu.brand,
+        vendor: cpu.vendor,
+        family: cpu.family,
+        model: cpu.model,
+        stepping: cpu.stepping,
+        revision: cpu.revision,
+        voltage: cpu.voltage,
+        speed: cpu.speed,
+        speedMin: cpu.speedMin,
+        speedMax: cpu.speedMax,
+        cores: cpu.cores,
+        physicalCores: cpu.physicalCores,
+        processors: cpu.processors,
+        socket: cpu.socket,
+        cache: cpu.cache
+      },
+      mem: {
+        total: mem.total,
+        free: mem.free,
+        used: mem.used,
+        active: mem.active,
+        available: mem.available,
+        swaptotal: mem.swaptotal,
+        swapused: mem.swapused,
+        swapfree: mem.swapfree
+      },
+      os: {
+        platform: osInfo.platform,
+        distro: osInfo.distro,
+        release: osInfo.release,
+        codename: osInfo.codename,
+        kernel: osInfo.kernel,
+        arch: osInfo.arch,
+        hostname: osInfo.hostname,
+        fqdn: osInfo.fqdn,
+        codepage: osInfo.codepage,
+        logofile: osInfo.logofile,
+        build: osInfo.build,
+        servicepack: osInfo.servicepack,
+        uefi: osInfo.uefi
+      },
+      graphics: {
+        controllers: graphics.controllers?.map(controller => ({
+          vendor: controller.vendor,
+          model: controller.model,
+          bus: controller.bus,
+          vram: controller.vram,
+          vramDynamic: controller.vramDynamic
+        })),
+        displays: graphics.displays?.map(display => ({
+          vendor: display.vendor,
+          model: display.model,
+          main: display.main,
+          builtin: display.builtin,
+          connection: display.connection,
+          resolutionX: display.resolutionX,
+          resolutionY: display.resolutionY,
+          sizeX: display.sizeX,
+          sizeY: display.sizeY,
+          pixelDepth: display.pixelDepth,
+          currentResX: display.currentResX,
+          currentResY: display.currentResY,
+          currentRefreshRate: display.currentRefreshRate
+        }))
+      },
+      system: {
+        manufacturer: system.manufacturer,
+        model: system.model,
+        version: system.version,
+        serial: system.serial,
+        uuid: system.uuid,
+        sku: system.sku,
+        virtual: system.virtual
+      }
+    };
+
+    logger.verbose('System information collected', {
+      cpuBrand: cpu.brand,
+      totalMemoryGB: (mem.total / (1024 * 1024 * 1024)).toFixed(2),
+      os: `${osInfo.distro} ${osInfo.release}`,
+      graphicsControllers: graphics.controllers?.length || 0,
+      displays: graphics.displays?.length || 0
+    });
+
+    return systemInfo;
+  } catch (error) {
+    logger.error('Failed to collect system information:', {
+      message: error.message,
+      stack: error.stack
+    });
+    
+    // Return minimal system info as fallback
+    return {
+      cpu: { brand: 'Unknown', cores: 0 },
+      mem: { total: 0 },
+      os: { 
+        platform: process.platform,
+        arch: process.arch,
+        release: process.version
+      },
+      graphics: { controllers: [], displays: [] },
+      system: { manufacturer: 'Unknown', model: 'Unknown' }
+    };
+  }
+}

package/lib/tracking/FileTracker.js

@@ -47,7 +47,7 @@ export class FileTracker {
         fs.writeFileSync(this.trackedFile, '', 'utf8');
       }
       
-      this.tail = new Tail(this.trackedFile, { encoding: 'ascii' });
+      this.tail = new Tail(this.trackedFile, { encoding: 'utf8' });
       this.tail.on('line', (line) => {
         const time = Date.now();
         this.eventTimes.push(time);

package/lib/tracking/icons/index.js

@@ -20,8 +20,9 @@ async function ensureIconModule() {
     const windowsModule = await import("./windows.js");
     getIconAsBuffer = windowsModule.getIconAsBuffer;
   } else {
-    // Linux fallback
-    getIconAsBuffer = () => null;
+    // Linux support
+    const linuxModule = await import("./linux.js");
+    getIconAsBuffer = linuxModule.getIconAsBuffer;
   }
   
   iconModuleLoaded = true;