dashcam 1.0.1-beta.2 → 1.0.1-beta.21

package/lib/processManager.js

@@ -2,12 +2,17 @@ import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { fileURLToPath } from 'url';
 import { logger } from './logger.js';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 // Use a fixed directory in the user's home directory for cross-process communication
 const PROCESS_DIR = path.join(os.homedir(), '.dashcam-cli');
 const PID_FILE = path.join(PROCESS_DIR, 'recording.pid');
 const STATUS_FILE = path.join(PROCESS_DIR, 'status.json');
+const RESULT_FILE = path.join(PROCESS_DIR, 'upload-result.json');
 
 // Ensure process directory exists
 if (!fs.existsSync(PROCESS_DIR)) {
@@ -47,6 +52,36 @@ class ProcessManager {
     }
   }
 
+  writeUploadResult(result) {
+    try {
+      logger.info('Writing upload result to file', { path: RESULT_FILE, shareLink: result.shareLink });
+      fs.writeFileSync(RESULT_FILE, JSON.stringify({
+        ...result,
+        timestamp: Date.now()
+      }, null, 2));
+      logger.info('Successfully wrote upload result to file');
+      // Verify it was written
+      if (fs.existsSync(RESULT_FILE)) {
+        logger.info('Verified upload result file exists');
+      } else {
+        logger.error('Upload result file does not exist after write!');
+      }
+    } catch (error) {
+      logger.error('Failed to write upload result file', { error });
+    }
+  }
+
+  readUploadResult() {
+    try {
+      if (!fs.existsSync(RESULT_FILE)) return null;
+      const data = fs.readFileSync(RESULT_FILE, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      logger.error('Failed to read upload result file', { error });
+      return null;
+    }
+  }
+
   writePid(pid = process.pid) {
     try {
       fs.writeFileSync(PID_FILE, pid.toString());
@@ -80,7 +115,8 @@ class ProcessManager {
     const status = this.readStatus();
     
     if (!pid || !this.isProcessRunning(pid)) {
-      this.cleanup();
+      // Clean up but preserve upload result in case the background process just finished uploading
+      this.cleanup({ preserveResult: true });
       return false;
     }
     
@@ -92,10 +128,12 @@ class ProcessManager {
     return this.readStatus();
   }
 
-  cleanup() {
+  cleanup(options = {}) {
+    const { preserveResult = false } = options;
     try {
       if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
       if (fs.existsSync(STATUS_FILE)) fs.unlinkSync(STATUS_FILE);
+      if (!preserveResult && fs.existsSync(RESULT_FILE)) fs.unlinkSync(RESULT_FILE);
     } catch (error) {
       logger.error('Failed to cleanup process files', { error });
     }
@@ -149,8 +187,8 @@ class ProcessManager {
             hasApps: result.apps?.length > 0
           });
           
-          // Cleanup process files
-          this.cleanup();
+          // Cleanup process files but preserve upload result for stop command
+          this.cleanup({ preserveResult: true });
           
           return result;
         } catch (recorderError) {
@@ -168,7 +206,7 @@ class ProcessManager {
             logs: []
           };
           
-          this.cleanup();
+          this.cleanup({ preserveResult: true });
           return result;
         }
       } else {
@@ -188,44 +226,68 @@ class ProcessManager {
       throw new Error('Recording already in progress');
     }
 
-    try {
-      // Import and call the recording function directly
-      const { startRecording } = await import('./recorder.js');
-      
-      const recordingOptions = {
-        fps: parseInt(options.fps) || 10,
-        includeAudio: options.audio || false,
-        customOutputPath: options.output || null
-      };
-
-      logger.info('Starting recording directly', { options: recordingOptions });
-
-      const result = await startRecording(recordingOptions);
-
-      // Write status to track the recording
-      this.writePid(process.pid);
-      this.writeStatus({
-        isRecording: true,
-        startTime: result.startTime, // Use actual recording start time from recorder
-        options,
-        pid: process.pid,
-        outputPath: result.outputPath
-      });
-
-      logger.info('Recording started successfully', { 
-        outputPath: result.outputPath,
-        startTime: result.startTime 
-      });
-
-      return {
-        pid: process.pid,
-        outputPath: result.outputPath,
-        startTime: result.startTime
-      };
-    } catch (error) {
-      logger.error('Failed to start recording', { error });
-      throw error;
+    // Always run in background mode by spawning a detached process
+    logger.info('Starting recording in background mode');
+    
+    // Get the path to the CLI binary
+    const binPath = path.join(__dirname, '..', 'bin', 'dashcam-background.js');
+    
+    logger.debug('Background process path', { binPath, exists: fs.existsSync(binPath) });
+    
+    // Create log files for background process
+    const logDir = PROCESS_DIR;
+    const stdoutLog = path.join(logDir, 'background-stdout.log');
+    const stderrLog = path.join(logDir, 'background-stderr.log');
+    
+    const stdoutFd = fs.openSync(stdoutLog, 'a');
+    const stderrFd = fs.openSync(stderrLog, 'a');
+    
+    // Spawn a detached process that will handle the recording
+    const backgroundProcess = spawn(process.execPath, [
+      binPath,
+      JSON.stringify(options)
+    ], {
+      detached: true,
+      stdio: ['ignore', stdoutFd, stderrFd], // Log stdout and stderr
+      env: {
+        ...process.env,
+        DASHCAM_BACKGROUND: 'true'
+      }
+    });
+    
+    // Close the file descriptors in the parent process
+    fs.closeSync(stdoutFd);
+    fs.closeSync(stderrFd);
+
+    // Get the background process PID before unreffing
+    const backgroundPid = backgroundProcess.pid;
+    
+    // Allow the parent process to exit independently
+    backgroundProcess.unref();
+
+    // Wait a moment for the background process to initialize
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // Read the status file to get recording details
+    const status = this.readStatus();
+    
+    if (!status || !status.isRecording) {
+      throw new Error('Background process failed to start recording');
     }
+
+    // Write PID file so other commands can find the background process
+    this.writePid(status.pid);
+
+    logger.info('Background recording process started', { 
+      pid: status.pid,
+      outputPath: status.outputPath
+    });
+
+    return {
+      pid: status.pid,
+      outputPath: status.outputPath,
+      startTime: status.startTime
+    };
   }
 
   async gracefulExit() {

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
     );
@@ -278,15 +321,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', 'good',     // Use 'good' quality preset (better than realtime, not as slow as best)
+    '-cpu-used', '4',       // Faster encoding (0-8, higher = faster but lower quality)
+    '-deadline', 'good',    // Good quality encoding mode
+    '-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 +407,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 +439,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 +511,41 @@ 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 longer for FFmpeg to finish gracefully - critical for VP9 encoding
+    // VP9 encoding needs time to flush buffers and finalize the container
     const gracefulTimeout = setTimeout(() => {
       if (currentRecording && !currentRecording.killed) {
+        logger.warn('FFmpeg did not exit gracefully after 8s, sending SIGTERM...');
         // If still running, try SIGTERM
         process.kill(currentRecording.pid, 'SIGTERM');
       }
-    }, 2000);
+    }, 8000); // Increased to 8 seconds for VP9 finalization
 
-    // Wait up to 5 seconds for SIGTERM to work
+    // Wait up to 15 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);
+    }, 15000); // Increased to 15 seconds
 
     // Wait for the process to fully exit
     if (currentRecording) {
@@ -489,8 +556,10 @@ 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));
+    // Additional wait to ensure filesystem is synced and encoder buffers are flushed
+    // This is especially important for VP9 which has larger encoding buffers
+    logger.debug('Waiting for filesystem sync and VP9 encoder finalization...');
+    await new Promise(resolve => setTimeout(resolve, 3000)); // Keep at 3 seconds after process exit
 
     // Read temp file path from disk (for cross-process access)
     let tempFile = currentTempFile; // Try in-memory first
@@ -538,21 +607,42 @@ 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...');
+    // Since WebM is already a valid streaming format, re-mux it 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 +712,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 +769,8 @@ export function getRecordingStatus() {
     outputPath
   };
 }
+
+/**
+ * Export the fix function for external use
+ */
+export { fixVideoContainer };

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,6 +41,12 @@ export class FileTracker {
     this.trackedFile = trackedFile;
 
     try {
+      // 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: 'ascii' });
       this.tail.on('line', (line) => {
         const time = Date.now();

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;