dashcam 1.0.1-beta.3 → 1.0.1-beta.31

package/lib/recorder.js

@@ -4,10 +4,52 @@ import { createGif, createSnapshot } from './ffmpeg.js';
 import { applicationTracker } from './applicationTracker.js';
 import { logsTrackerManager, trimLogs } from './logs/index.js';
 import { getFfmpegPath } from './binaries.js';
+import { APP } from './config.js';
 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
  */
@@ -104,8 +146,8 @@ let outputPath = null;
 let recordingStartTime = null;
 let currentTempFile = null;
 
-// File paths - use system temp for runtime data
-const DASHCAM_TEMP_DIR = path.join(os.tmpdir(), 'dashcam');
+// File paths - use APP config directory for better Windows compatibility
+const DASHCAM_TEMP_DIR = APP.configDir;
 const TEMP_FILE_INFO_PATH = path.join(DASHCAM_TEMP_DIR, 'temp-file.json');
 
 // Platform-specific configurations
@@ -116,9 +158,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 +201,7 @@ async function getPlatformArgs({ fps, includeAudio }) {
   });
   
   const args = [
+    '-thread_queue_size', '512',  // Increase input buffer to prevent drops
     '-f', config.inputFormat
   ];
 
@@ -170,12 +212,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
     );
@@ -195,12 +239,12 @@ async function getPlatformArgs({ fps, includeAudio }) {
 }
 
 /**
- * Clear the tmp/recordings directory
+ * Clear the recordings directory
  */
 function clearRecordingsDirectory() {
   const logExit = logFunctionCall('clearRecordingsDirectory');
   
-  const directory = path.join(process.cwd(), 'tmp', 'recordings');
+  const directory = APP.recordingsDir;
   
   try {
     if (fs.existsSync(directory)) {
@@ -238,8 +282,8 @@ function generateOutputPath() {
   const logExit = logFunctionCall('generateOutputPath');
   
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  // Use system temp directory with dashcam subdirectory
-  const directory = path.join(os.tmpdir(), 'dashcam', 'recordings');
+  // Use APP recordings directory for consistent cross-platform location
+  const directory = APP.recordingsDir;
   const filepath = path.join(directory, `recording-${timestamp}.webm`);
   
   logger.verbose('Generating output path', {
@@ -278,15 +322,21 @@ export async function startRecording({
   // Construct FFmpeg command arguments
   const platformArgs = await getPlatformArgs({ fps, includeAudio });
   const outputArgs = [
-    '-c:v', 'libvpx',      // Use VP8 codec instead of VP9 for better compatibility
-    '-b:v', '1M',          // Set specific bitrate instead of variable
-    // Remove explicit pixel format to let ffmpeg handle conversion automatically
+    '-c:v', 'libvpx-vp9',  // Use VP9 codec for better quality and compression
+    '-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', '30',            // Keyframe every 30 frames
-    // 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) {
@@ -358,13 +408,11 @@ export async function startRecording({
       all: true, // Capture both stdout and stderr
       stdin: 'pipe' // Enable stdin for sending 'q' to stop recording
     });
-
-    recordingStartTime = Date.now();
     
     logger.info('FFmpeg process spawned', { 
       pid: currentRecording.pid,
       args: args.slice(-5), // Log last 5 args including output file
-      tempFile 
+      tempFile
     });
     
     // Check if temp file gets created within first few seconds
@@ -392,6 +440,14 @@ export async function startRecording({
       directory: path.dirname(outputPath)
     });
 
+    // Set recording start time AFTER log tracker is initialized
+    // This ensures the timeline starts when the tracker is ready to capture events
+    recordingStartTime = Date.now();
+    logger.info('Recording timeline started', { 
+      recordingStartTime,
+      recordingStartTimeReadable: new Date(recordingStartTime).toISOString()
+    });
+
     if (currentRecording.all) {
       currentRecording.all.setEncoding('utf8');
       currentRecording.all.on('data', (data) => {
@@ -456,29 +512,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) {
@@ -489,8 +556,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
@@ -538,21 +627,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);
     }
 
@@ -622,6 +731,12 @@ export async function stopRecording() {
       icons: appTrackingResults.icons, // Include application icons metadata
       logs: logTrackingResults // Include log tracking results
     };
+    
+    logger.info('Recording stopped with clientStartDate', {
+      clientStartDate: recordingStartTime,
+      clientStartDateReadable: new Date(recordingStartTime).toISOString(),
+      duration: result.duration
+    });
 
     currentRecording = null;
     recordingStartTime = null;
@@ -673,3 +788,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

@@ -1,5 +1,6 @@
 import { Tail } from 'tail';
 import { logger } from '../logger.js';
+import fs from 'fs';
 
 // Simple function to get stats for events in the last minute
 function getStats(eventTimes = []) {
@@ -40,7 +41,13 @@ export class FileTracker {
     this.trackedFile = trackedFile;
 
     try {
-      this.tail = new Tail(this.trackedFile, { encoding: 'ascii' });
+      // Ensure the file exists before creating the Tail watcher
+      if (!fs.existsSync(this.trackedFile)) {
+        logger.warn(`File does not exist, creating: ${this.trackedFile}`);
+        fs.writeFileSync(this.trackedFile, '', 'utf8');
+      }
+      
+      this.tail = new Tail(this.trackedFile, { encoding: 'utf8' });
       this.tail.on('line', (line) => {
         const time = Date.now();
         this.eventTimes.push(time);

package/lib/tracking/LogsTracker.js

@@ -55,6 +55,7 @@ export class LogsTracker {
 
     this.files[filePath] = {
       status,
+      filePath, // Store file path for later reference
       unsubscribe: this.fileTrackerManager.subscribe(filePath, callback),
     };
     
@@ -98,13 +99,25 @@ export class LogsTracker {
 
   getStatus() {
     let items = [];
+    let filePathMap = {};
+    
     if (this.isWatchOnly) {
-      items = Object.keys(this.files).map((filePath) => ({
-        ...this.fileTrackerManager.getStats(filePath),
-        item: this.fileToIndex[filePath],
-      }));
+      items = Object.keys(this.files).map((filePath) => {
+        const index = this.fileToIndex[filePath];
+        filePathMap[index] = filePath;
+        return {
+          ...this.fileTrackerManager.getStats(filePath),
+          item: index, // Keep numeric index to match events
+        };
+      });
     } else {
-      items = Object.values(this.files).map(({ status }) => status);
+      items = Object.values(this.files).map(({ status, filePath }) => {
+        const index = status.item;
+        filePathMap[index] = filePath;
+        return {
+          ...status,
+        };
+      });
     }
 
     const totalCount = items.reduce((acc, status) => acc + status.count, 0);
@@ -112,11 +125,12 @@ export class LogsTracker {
     return [
       {
         id: 'CLI',
-        name: 'CLI',
+        name: 'File Logs', // More descriptive name
         type: 'cli',
         fileLocation: this.fileLocation,
         items: items,
         count: totalCount,
+        filePathMap: filePathMap, // Include mapping for UI to display file paths
       },
     ];
   }
@@ -126,7 +140,7 @@ export class LogsTracker {
     const status = this.getStatus();
     return status.length > 0 ? status[0] : {
       id: 'CLI',
-      name: 'CLI', 
+      name: 'File Logs', 
       type: 'cli',
       fileLocation: this.fileLocation,
       items: [],

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;