dashcam 1.3.31 → 1.4.1-beta

package/bin/dashcam-background.js

@@ -4,7 +4,7 @@
  * This script runs detached from the parent process to handle long-running recordings
  */
 
-import { startRecording, stopRecording } from '../lib/recorder.js';
+import { startRecording } from '../lib/recorder.js';
 import { logger, setVerbose } from '../lib/logger.js';
 import fs from 'fs';
 import path from 'path';
@@ -161,56 +161,13 @@ async function runBackgroundRecording() {
       }
       isShuttingDown = true;
       
-      logger.info(`Received ${signal}, stopping background recording...`);
-      console.log('[Background] Received stop signal, stopping recording...');
+      logger.info(`Received ${signal}, background process will be killed`);
+      console.log('[Background] Received stop signal, process will be terminated...');
       
-      try {
-        // Stop the recording
-        const stopResult = await stopRecording();
-        
-        if (stopResult) {
-          logger.info('Recording stopped successfully', { 
-            outputPath: stopResult.outputPath,
-            duration: stopResult.duration 
-          });
-          console.log('[Background] Recording stopped successfully:', {
-            outputPath: stopResult.outputPath,
-            duration: stopResult.duration
-          });
-          
-          // Write recording result for stop command to upload
-          console.log('[Background] Writing recording result for stop command...');
-          writeRecordingResult({
-            outputPath: stopResult.outputPath,
-            duration: stopResult.duration,
-            clientStartDate: stopResult.clientStartDate,
-            apps: stopResult.apps,
-            logs: stopResult.logs,
-            gifPath: stopResult.gifPath,
-            snapshotPath: stopResult.snapshotPath,
-            // Include options so stop command can use them for upload
-            title: options.title,
-            description: options.description,
-            project: options.project || options.k
-          });
-          console.log('[Background] Recording result written successfully');
-        }
-        
-        // Update status to indicate recording stopped
-        writeStatus({
-          isRecording: false,
-          completedTime: Date.now(),
-          pid: process.pid
-        });
-        
-        console.log('[Background] Background process exiting successfully');
-        logger.info('Background process exiting successfully');
-        process.exit(0);
-      } catch (error) {
-        console.error('[Background] Error during shutdown:', error.message);
-        logger.error('Error during shutdown:', error);
-        process.exit(1);
-      }
+      // 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);
     };
     
     // Register signal handlers

package/bin/dashcam.js

@@ -137,7 +137,7 @@ async function recordingAction(options, command) {
 
       // Add timeout to prevent hanging
       const startRecordingPromise = processManager.startRecording({
-        fps: parseInt(options.fps) || 30,
+        fps: parseInt(options.fps) || 10,
         audio: options.audio,
         output: options.output,
         title: options.title,
@@ -241,7 +241,7 @@ program
   .command('record')
   .description('Start a recording terminal to be included in your dashcam video recording')
   .option('-a, --audio', 'Include audio in the recording')
-  .option('-f, --fps <fps>', 'Frames per second (default: 30)', '30')
+  .option('-f, --fps <fps>', 'Frames per second (default: 10)', '10')
   .option('-o, --output <path>', 'Custom output path')
   .option('-t, --title <title>', 'Title for the recording')
   .option('-d, --description <description>', 'Description for the recording (supports markdown)')
@@ -484,9 +484,36 @@ program
           logger.error('Failed to read temp file info', { error });
         }
         
-        const tempFile = tempFileInfo?.tempFile || result.outputPath.replace('.webm', '-temp.webm');
+        // Fallback: look for temp files in the same directory
+        let tempFile = tempFileInfo?.tempFile;
+        if (!tempFile || !fs.existsSync(tempFile)) {
+          // Try to find any temp-*.webm file in the output directory
+          const outputDir = path.dirname(result.outputPath);
+          if (fs.existsSync(outputDir)) {
+            const files = fs.readdirSync(outputDir);
+            const tempFiles = files.filter(f => f.startsWith('temp-') && f.endsWith('.webm'));
+            if (tempFiles.length > 0) {
+              // Use the most recent temp file
+              tempFiles.sort().reverse();
+              tempFile = path.join(outputDir, tempFiles[0]);
+              logger.info('Found temp file in output directory', { tempFile });
+            }
+          }
+        }
+        
         const outputPath = result.outputPath;
         
+        // Verify we have a temp file to work with
+        if (!tempFile) {
+          console.error('No temp file found for recording');
+          logger.error('Temp file missing', { 
+            tempFileInfo, 
+            outputDir: path.dirname(result.outputPath),
+            expectedPattern: 'temp-*.webm'
+          });
+          process.exit(1);
+        }
+        
         // Fix the video with FFmpeg (handle incomplete recordings)
         logger.info('Fixing video with FFmpeg', { tempFile, outputPath });
         if (fs.existsSync(tempFile)) {
@@ -502,14 +529,129 @@ program
           logger.warn('Temp file not found, using output path directly', { tempFile });
         }
         
-        // We killed the process, so we don't have apps/logs data
-        // The recording is still on disk and can be uploaded without metadata
+        // Verify the output file exists before proceeding
+        if (!fs.existsSync(outputPath)) {
+          console.error('Recording file not found after processing');
+          logger.error('Output file missing', { outputPath, tempFile, tempFileExists: fs.existsSync(tempFile) });
+          process.exit(1);
+        }
+        
+        logger.info('Output file ready for upload', { 
+          outputPath, 
+          size: fs.statSync(outputPath).size 
+        });
+        
+        // Generate paths for additional assets
+        const basePath = outputPath.substring(0, outputPath.lastIndexOf('.'));
+        const gifPath = `${basePath}.gif`;
+        const snapshotPath = `${basePath}.png`;
+        
+        // Create GIF and snapshot (non-blocking, don't fail if these fail)
+        console.log('Creating preview assets...');
+        const { createGif, createSnapshot } = await import('../lib/ffmpeg.js');
+        
+        // Add timeout wrapper to prevent hanging on large files
+        const withTimeout = (promise, timeoutMs, name) => {
+          return Promise.race([
+            promise,
+            new Promise((_, reject) => 
+              setTimeout(() => reject(new Error(`${name} timed out after ${timeoutMs}ms`)), timeoutMs)
+            )
+          ]);
+        };
+        
+        try {
+          await Promise.all([
+            withTimeout(
+              createGif(outputPath, gifPath),
+              30000, // 30 second timeout
+              'GIF creation'
+            ).catch(err => {
+              logger.warn('Failed to create GIF', { error: err.message });
+            }),
+            withTimeout(
+              createSnapshot(outputPath, snapshotPath, 0),
+              10000, // 10 second timeout
+              'Snapshot creation'
+            ).catch(err => {
+              logger.warn('Failed to create snapshot', { error: err.message });
+            })
+          ]);
+          logger.debug('Preview assets created successfully');
+        } catch (error) {
+          logger.warn('Failed to create preview assets', { error: error.message });
+        }
+        
+        // Collect logs and app tracking data
+        console.log('Collecting tracking data...');
+        
+        // Get app tracking data
+        const { applicationTracker } = await import('../lib/applicationTracker.js');
+        const appTrackingResults = applicationTracker.stop();
+        logger.info('Collected app tracking results', {
+          apps: appTrackingResults.apps?.length || 0,
+          icons: appTrackingResults.icons?.length || 0,
+          events: appTrackingResults.events?.length || 0
+        });
+        
+        // Get log tracking data - read directly from files since background process was killed
+        const recordingDir = path.dirname(outputPath);
+        let logTrackingResults = [];
+        
+        try {
+          // Check for CLI logs file
+          const cliLogsFile = path.join(recordingDir, 'dashcam_logs_cli.jsonl');
+          if (fs.existsSync(cliLogsFile)) {
+            const { jsonl } = await import('../lib/utilities/jsonl.js');
+            const cliLogs = jsonl.read(cliLogsFile);
+            if (cliLogs && cliLogs.length > 0) {
+              logTrackingResults.push({
+                type: 'cli',
+                name: 'CLI Logs',
+                fileLocation: cliLogsFile,
+                count: cliLogs.length,
+                trimmedFileLocation: cliLogsFile
+              });
+              logger.info('Found CLI logs', { count: cliLogs.length, file: cliLogsFile });
+            }
+          }
+          
+          // Check for web logs file
+          const webLogsFile = path.join(recordingDir, 'dashcam_logs_web_events.jsonl');
+          if (fs.existsSync(webLogsFile)) {
+            const { jsonl } = await import('../lib/utilities/jsonl.js');
+            const webLogs = jsonl.read(webLogsFile);
+            if (webLogs && webLogs.length > 0) {
+              logTrackingResults.push({
+                type: 'web',
+                name: 'Web Logs',
+                fileLocation: webLogsFile,
+                count: webLogs.length,
+                trimmedFileLocation: webLogsFile
+              });
+              logger.info('Found web logs', { count: webLogs.length, file: webLogsFile });
+            }
+          }
+          
+          logger.info('Collected log tracking results', { 
+            trackers: logTrackingResults.length,
+            totalEvents: logTrackingResults.reduce((sum, result) => sum + result.count, 0)
+          });
+        } catch (error) {
+          logger.warn('Failed to collect log tracking results', { error: error.message });
+        }
+        
+        // The recording is on disk and can be uploaded with full metadata
         const recordingResult = {
           outputPath,
+          gifPath,
+          snapshotPath,
           duration: result.duration,
+          fileSize: fs.statSync(outputPath).size,
           clientStartDate: activeStatus.startTime,
-          apps: [],
-          logs: [],
+          apps: appTrackingResults.apps,
+          icons: appTrackingResults.icons,
+          logs: logTrackingResults,
           title: activeStatus?.options?.title,
           description: activeStatus?.options?.description,
           project: activeStatus?.options?.project
@@ -532,6 +674,7 @@ program
             duration: recordingResult.duration,
             clientStartDate: recordingResult.clientStartDate,
             apps: recordingResult.apps,
+            icons: recordingResult.icons,
             logs: recordingResult.logs,
             gifPath: recordingResult.gifPath,
             snapshotPath: recordingResult.snapshotPath
@@ -749,7 +892,7 @@ program
       if (!targetFile) {
         console.error('Please provide a file path or use --recover option');
         console.log('Examples:');
-        console.log('  dashcam upload /path/to/recording.webm');
+        console.log('  dashcam upload /path/to/recording.mp4');
         console.log('  dashcam upload --recover');
         process.exit(1);
       }

package/lib/ffmpeg.js

@@ -72,8 +72,8 @@ export async function createGif(inputVideoPath, outputGifPath) {
     throw new Error('Video file is not ready or is corrupted');
   }
 
-  const gifFps = 4;
-  const gifDuration = 10;
+  const gifFps = 2; // Reduced from 4 to 2 fps for faster generation
+  const gifDuration = 5; // Reduced from 10 to 5 seconds for faster generation
   const gifFrames = Math.ceil(gifDuration * gifFps);
 
   // Get video duration in seconds
@@ -94,8 +94,8 @@ export async function createGif(inputVideoPath, outputGifPath) {
       stdout
     });
     
-    // Fallback: Single-pass GIF creation at fixed rate
-    const filters = `fps=1/3,scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=128[p];[s1][p]paletteuse=dither=bayer:bayer_scale=5`;
+    // Fallback: Fast GIF creation with reduced quality
+    const filters = `fps=2,scale=480:-1:flags=fast_bilinear,split[s0][s1];[s0]palettegen=max_colors=64[p];[s1][p]paletteuse=dither=none`;
     
     await execa(ffmpegPath, [
       '-i', inputVideoPath,
@@ -111,8 +111,12 @@ export async function createGif(inputVideoPath, outputGifPath) {
   
   const extractedFramesInterval = videoDuration / gifFrames;
 
-  // Single-pass GIF creation with palette for better quality and performance
-  const filters = `fps=1/${extractedFramesInterval},scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=128[p];[s1][p]paletteuse=dither=bayer:bayer_scale=5`;
+  // Fast GIF creation with reduced quality for speed
+  // - Smaller scale (480 vs 640)
+  // - Fewer colors (64 vs 128)
+  // - Faster scaling algorithm (fast_bilinear vs lanczos)
+  // - No dithering for faster processing
+  const filters = `fps=1/${extractedFramesInterval},scale=480:-1:flags=fast_bilinear,split[s0][s1];[s0]palettegen=max_colors=64[p];[s1][p]paletteuse=dither=none`;
   
   await execa(ffmpegPath, [
     '-i', inputVideoPath,

package/lib/recorder.js

@@ -3,7 +3,7 @@ import { logger, logFunctionCall } from './logger.js';
 import { createGif, createSnapshot } from './ffmpeg.js';
 import { applicationTracker } from './applicationTracker.js';
 import { logsTrackerManager, trimLogs } from './logs/index.js';
-import { getFfmpegPath } from './binaries.js';
+import { getFfmpegPath, getFfprobePath } from './binaries.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs';
@@ -27,7 +27,7 @@ async function fixVideoContainer(inputVideoPath, outputVideoPath) {
       '-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
+      '-f', 'webm',             // Force WebM format
       outputVideoPath,
       '-y',                     // Overwrite output file
       '-hide_banner'
@@ -320,8 +320,9 @@ export async function startRecording({
   
   // Construct FFmpeg command arguments
   const platformArgs = await getPlatformArgs({ fps, includeAudio });
+
   const outputArgs = [
-    '-c:v', 'libvpx-vp9',  // Use VP9 codec for better quality and compression
+    '-c:v', 'libvpx',  // 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
@@ -340,7 +341,7 @@ export async function startRecording({
 
   if (includeAudio) {
     outputArgs.push(
-      '-c:a', 'libopus',   // Opus audio codec for WebM
+      '-c:a', 'libvorbis', // Vorbis audio codec for WebM
       '-b:a', '128k'
     );
   }
@@ -535,6 +536,9 @@ export async function stopRecording() {
   }
 
   try {
+    const platform = os.platform();
+    const isWindows = platform === 'win32';
+    
     // First try to gracefully stop FFmpeg by sending 'q'
     if (currentRecording && currentRecording.stdin) {
       logger.debug('Sending quit signal to FFmpeg...');
@@ -545,18 +549,36 @@ export async function stopRecording() {
     // 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');
+        logger.warn('FFmpeg did not exit gracefully after 10s, forcing termination...');
+        // Use platform-appropriate termination
+        if (isWindows) {
+          // On Windows, use taskkill for clean termination
+          try {
+            execa.sync('taskkill', ['/PID', currentRecording.pid.toString(), '/T']);
+          } catch (e) {
+            logger.warn('taskkill failed, ffmpeg may have already exited');
+          }
+        } else {
+          // On Unix, use SIGTERM
+          process.kill(currentRecording.pid, 'SIGTERM');
+        }
       }
     }, 10000); // Wait longer for graceful shutdown
 
-    // Wait up to 20 seconds for SIGTERM to work
+    // Wait up to 20 seconds for termination 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');
+        logger.error('FFmpeg still running after termination, forcing kill...');
+        // Use platform-appropriate forced kill
+        if (isWindows) {
+          try {
+            execa.sync('taskkill', ['/F', '/PID', currentRecording.pid.toString(), '/T']);
+          } catch (e) {
+            logger.warn('taskkill /F failed, ffmpeg may have already exited');
+          }
+        } else {
+          process.kill(currentRecording.pid, 'SIGKILL');
+        }
       }
     }, 20000); // Longer timeout to avoid killing prematurely
 
@@ -570,20 +592,39 @@ export async function stopRecording() {
     clearTimeout(hardKillTimeout);
 
     // Wait for filesystem to sync and file to be written
+    // This is critical on Windows where file writes may be buffered
+    
+    // Windows needs extra time for file system sync
+    const extraSyncTime = isWindows ? 3000 : 1000;
+    logger.debug(`Waiting ${extraSyncTime}ms for file system to sync...`);
+    await new Promise(resolve => setTimeout(resolve, extraSyncTime));
+    
     // 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 maxWaitTime = 15000; // Increased from 10s to 15s for Windows
     const startWait = Date.now();
     let tempFileReady = false;
+    let lastSize = 0;
+    let stableCount = 0;
     
     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;
+          // Check if file size is stable (hasn't changed)
+          if (stats.size === lastSize) {
+            stableCount++;
+            // Consider ready after size is stable for 2 consecutive checks
+            if (stableCount >= 2) {
+              logger.debug('Temp file is ready and stable', { size: stats.size });
+              tempFileReady = true;
+              break;
+            }
+          } else {
+            stableCount = 0;
+          }
+          lastSize = stats.size;
         }
       }
       // Wait a bit before checking again
@@ -591,7 +632,7 @@ export async function stopRecording() {
     }
     
     if (!tempFileReady) {
-      logger.warn('Temp file not ready after waiting, proceeding anyway');
+      logger.warn('Temp file not confirmed stable after waiting, proceeding anyway', { lastSize });
     }
 
     // Read temp file path from disk (for cross-process access)
@@ -640,6 +681,63 @@ export async function stopRecording() {
       path: tempFile
     });
 
+    // Validate that the file is readable by ffprobe before attempting re-mux
+    logger.debug('Validating temp file integrity with ffprobe...');
+    const ffprobePath = await getFfprobePath();
+    try {
+      const { exitCode, stderr } = await execa(ffprobePath, [
+        '-v', 'error',
+        '-select_streams', 'v:0',
+        '-show_entries', 'stream=codec_type',
+        '-of', 'default=noprint_wrappers=1:nokey=1',
+        tempFile
+      ], { reject: false });
+      
+      if (exitCode !== 0) {
+        logger.warn('Temp file validation failed', { exitCode, stderr });
+        // File may be corrupted, but we'll try to process it anyway
+        // Skip re-muxing and just copy the file
+        logger.warn('Skipping re-mux due to validation failure, copying file directly');
+        fs.copyFileSync(tempFile, outputPath);
+        
+        // Clean up temp file
+        try {
+          fs.unlinkSync(tempFile);
+        } catch (e) {
+          logger.debug('Failed to delete temp file:', e);
+        }
+        
+        // Skip the re-mux process below
+        const result = {
+          outputPath,
+          gifPath: `${outputPath.substring(0, outputPath.lastIndexOf('.'))}.gif`,
+          snapshotPath: `${outputPath.substring(0, outputPath.lastIndexOf('.'))}.png`,
+          duration: Date.now() - recordingStartTime,
+          fileSize: fs.existsSync(outputPath) ? fs.statSync(outputPath).size : 0,
+          clientStartDate: recordingStartTime,
+          apps: applicationTracker.stop().apps,
+          icons: applicationTracker.stop().icons,
+          logs: await logsTrackerManager.stop({ recorderId: path.basename(outputPath).replace('.webm', ''), screenId: '1' })
+        };
+        
+        currentRecording = null;
+        recordingStartTime = null;
+        currentTempFile = null;
+        
+        if (fs.existsSync(TEMP_FILE_INFO_PATH)) {
+          fs.unlinkSync(TEMP_FILE_INFO_PATH);
+        }
+        
+        logExit();
+        return result;
+      }
+      
+      logger.debug('Temp file validation passed');
+    } catch (error) {
+      logger.warn('Failed to validate temp file', { error: error.message });
+      // Continue with re-mux attempt anyway
+    }
+
     // Re-mux to ensure proper container metadata (duration, seekability, etc.)
     logger.debug('Re-muxing temp file to fix container metadata...');
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashcam",
-  "version": "1.3.31",
+  "version": "1.4.1-beta",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/dashcam.js",
   "bin": {

package/test_workflow.sh

@@ -34,12 +34,11 @@ echo "✅ File tracking configured"
 echo ""
 echo "4. Starting dashcam recording in background..."
 # Start recording and redirect output to a log file so we can still monitor it
-./bin/dashcam.js record --title "Sync Test Recording" --description "Testing video/log synchronization with timestamped events" > /tmp/dashcam-recording.log 2>&1 &
-RECORD_PID=$!
+./bin/dashcam.js record --title "Sync Test Recording" --description "Testing video/log synchronization with timestamped events" > /tmp/dashcam-recording.log 2>&1
 
 # Wait for recording to initialize and log tracker to start
-echo "Waiting for recording to initialize (PID: $RECORD_PID)..."
-sleep 1
+echo "Waiting for recording to initialize..."
+sleep 2
 
 # Write first event after log tracker is fully ready
 RECORDING_START=$(date +%s)
@@ -48,11 +47,12 @@ echo "🔴 EVENT 1: Recording START at $(date '+%H:%M:%S')"
 echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
 echo "[EVENT 1] 🔴 Recording started with emoji at $(date '+%H:%M:%S') - TIMESTAMP: $RECORDING_START" >> "$TEMP_FILE"
 
-# Verify recording is actually running
-if ps -p $RECORD_PID > /dev/null; then
+# Verify background recording process is actually running
+if pgrep -f "dashcam-background.js" > /dev/null; then
   echo "✅ Recording started successfully"
 else
   echo "❌ Recording process died, check /tmp/dashcam-recording.log"
+  cat /tmp/dashcam-recording.log
   exit 1
 fi