dashcam 1.3.30 → 1.4.0-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)')
@@ -474,8 +474,6 @@ program
         logger.debug('Reconstructing recording data from status file');
         
         const { fixVideoContainer } = await import('../lib/recorder.js');
-        const { applicationTracker } = await import('../lib/applicationTracker.js');
-        const { logsTrackerManager } = await import('../lib/logs/index.js');
         
         // Get temp file path
         const tempFileInfoPath = path.join(os.tmpdir(), 'dashcam', 'temp-file.json');
@@ -486,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)) {
@@ -504,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
@@ -534,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
@@ -751,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/examples/execute-script.js

@@ -14,10 +14,10 @@ import { WebTrackerManager } from '../lib/extension-logs/manager.js';
 import { logger } from '../lib/logger.js';
 
 async function main() {
-  console.log('╔════════════════════════════════════════════════════════════════╗');
-  console.log('║  Chrome Extension Script Execution Example                    ║');
-  console.log('╚════════════════════════════════════════════════════════════════╝\n');
-  console.log('📋 Prerequisites:');
+  console.log('================================================================');
+  console.log('  Chrome Extension Script Execution Example');
+  console.log('================================================================\n');
+  console.log('Prerequisites:');
   console.log('  1. Chrome extension must be installed and loaded');
   console.log('  2. Have a regular webpage open (NOT chrome:// or chrome-extension://)');
   console.log('  3. For best results, navigate to a simple page like example.com\n');
@@ -26,21 +26,19 @@ async function main() {
   
   // Start the WebSocket server
   await server.start();
-  console.log('✓ WebSocket server started on port:', server.port);
-  
-  // Create the WebTrackerManager
+    console.log('WebSocket server started on port:', server.port);  // Create the WebTrackerManager
   const manager = new WebTrackerManager(server);
   
   // Wait for the Chrome extension to connect
   console.log('\nWaiting for Chrome extension to connect...');
   const connected = await new Promise((resolve) => {
     const timeout = setTimeout(() => {
-      console.log('⏱️  Timeout waiting for connection');
+      console.log('Timeout waiting for connection');
       resolve(false);
     }, 10000);
     
     const cleanup = server.on('connection', (client) => {
-      console.log('✓ Chrome extension connected!');
+      console.log('Chrome extension connected!');
       clearTimeout(timeout);
       cleanup();
       resolve(true);
@@ -48,7 +46,7 @@ async function main() {
   });
   
   if (!connected) {
-    console.error('\n❌ Chrome extension did not connect.');
+    console.error('\nChrome extension did not connect.');
     console.error('   Make sure the extension is installed and running.');
     console.error('   Check chrome://extensions to verify it\'s loaded.');
     process.exit(1);
@@ -62,9 +60,9 @@ async function main() {
     const result = await manager.executeScript({
       code: 'return document.title;'
     });
-    console.log('✓ Page title:', result);
+      console.log('Page title:', result);
   } catch (error) {
-    console.error('❌ Error:', error.message);
+    console.error('Error:', error.message);
   }
   
   console.log('\n--- Example 2: Get current URL ---');
@@ -96,7 +94,7 @@ async function main() {
       code: `
         const div = document.createElement('div');
         div.style.cssText = 'position: fixed; top: 20px; right: 20px; background: #4CAF50; color: white; padding: 20px; border-radius: 8px; font-family: Arial; z-index: 10000; box-shadow: 0 4px 6px rgba(0,0,0,0.1);';
-        div.textContent = 'Hello from CLI! 👋';
+        div.textContent = 'Hello from CLI!';
         document.body.appendChild(div);
         
         // Remove after 5 seconds

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/logger.js

@@ -109,9 +109,9 @@ logger.trace = (message, meta) => logger.silly(`[TRACE] ${message}`, meta);
 // Function to log function entry/exit for debugging
 export function logFunctionCall(functionName, args = {}) {
   if (isVerbose) {
-    logger.debug(`→ Entering ${functionName}`, { args });
+    logger.debug(`Entering ${functionName}`, { args });
     return (result) => {
-      logger.debug(`← Exiting ${functionName}`, { result: typeof result });
+      logger.debug(`Exiting ${functionName}`, { result: typeof result });
     };
   }
   return () => {}; // No-op if not verbose

package/lib/permissions.js

@@ -50,7 +50,7 @@ function showPermissionInstructions() {
     return;
   }
 
-  console.log('\n⚠️  Screen Recording Permission Required\n');
+  console.log('\nScreen Recording Permission Required\n');
   console.log('Dashcam needs screen recording permission to capture your screen.');
   console.log('\nTo grant permission:');
   console.log('1. Open System Settings (or System Preferences)');

package/lib/recorder.js

@@ -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'
     );
   }

package/package.json

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

package/test-short-recording.js

@@ -30,17 +30,17 @@ import os from 'os';
 async function analyzeVideo(videoPath) {
   const ffprobePath = await getFfprobePath();
   
-  console.log(`\n📊 Analyzing video: ${videoPath}`);
-  console.log('─'.repeat(80));
+  console.log(`\nAnalyzing video: ${videoPath}`);
+  console.log('='.repeat(80));
   
   // Check if file exists
   if (!fs.existsSync(videoPath)) {
-    console.error(`❌ Video file does not exist: ${videoPath}`);
+    console.error(`Video file does not exist: ${videoPath}`);
     return null;
   }
   
   const stats = fs.statSync(videoPath);
-  console.log(`📁 File size: ${(stats.size / 1024).toFixed(2)} KB`);
+  console.log(`File size: ${(stats.size / 1024).toFixed(2)} KB`);
   
   try {
     // Get basic format info
@@ -52,8 +52,8 @@ async function analyzeVideo(videoPath) {
     ]);
     
     const formatData = JSON.parse(formatResult.stdout);
-    console.log(`⏱️  Duration: ${formatData.format.duration || 'unknown'}s`);
-    console.log(`📊 Bit rate: ${formatData.format.bit_rate || 'unknown'} bits/s`);
+    console.log(`Duration: ${formatData.format.duration || 'unknown'}s`);
+    console.log(`Bit rate: ${formatData.format.bit_rate || 'unknown'} bits/s`);
     
     // Get stream info
     const streamResult = await execa(ffprobePath, [
@@ -67,9 +67,9 @@ async function analyzeVideo(videoPath) {
     const videoStream = streamData.streams.find(s => s.codec_name);
     
     if (videoStream) {
-      console.log(`🎥 Codec: ${videoStream.codec_name}`);
-      console.log(`📐 Resolution: ${videoStream.width}x${videoStream.height}`);
-      console.log(`🎞️  Frame rate: ${videoStream.r_frame_rate}`);
+      console.log(`Codec: ${videoStream.codec_name}`);
+      console.log(`Resolution: ${videoStream.width}x${videoStream.height}`);
+      console.log(`Frame rate: ${videoStream.r_frame_rate}`);
     }
     
     // Count actual frames
@@ -83,10 +83,10 @@ async function analyzeVideo(videoPath) {
     ], { reject: false });
     
     const frameCount = parseInt(frameResult.stdout.trim());
-    console.log(`🖼️  Frame count: ${frameCount || 'unknown'}`);
+    console.log(`Frame count: ${frameCount || 'unknown'}`);
     
     if (frameResult.stderr) {
-      console.log(`⚠️  FFprobe warnings: ${frameResult.stderr.trim()}`);
+      console.log(`FFprobe warnings: ${frameResult.stderr.trim()}`);
     }
     
     // Check if duration is available in container
@@ -97,10 +97,10 @@ async function analyzeVideo(videoPath) {
     const hasEncodingIssues = frameResult.stderr.includes('File ended prematurely');
     const hasMissingMetadata = !hasDuration;
     
-    console.log('\n📋 Analysis Result:');
-    console.log(`   Single frame: ${isSingleFrame ? '❌ YES (BUG!)' : '✅ NO'}`);
-    console.log(`   Encoding issues: ${hasEncodingIssues ? '⚠️  YES' : '✅ NO'}`);
-    console.log(`   Missing metadata: ${hasMissingMetadata ? '⚠️  YES (container incomplete)' : '✅ NO'}`);
+    console.log('\nAnalysis Result:');
+    console.log(`   Single frame: ${isSingleFrame ? 'YES (BUG!)' : 'NO'}`);
+    console.log(`   Encoding issues: ${hasEncodingIssues ? 'YES' : 'NO'}`);
+    console.log(`   Missing metadata: ${hasMissingMetadata ? 'YES (container incomplete)' : 'NO'}`);
     console.log(`   Platform: ${os.platform()}`);
     
     return {
@@ -117,34 +117,34 @@ async function analyzeVideo(videoPath) {
     };
     
   } catch (error) {
-    console.error(`❌ Error analyzing video: ${error.message}`);
+    console.error(`Error analyzing video: ${error.message}`);
     return null;
   }
 }
 
 async function testShortRecording(duration = 3000) {
-  console.log(`\n🎬 Testing ${duration}ms recording...`);
-  console.log('═'.repeat(80));
+  console.log(`\nTesting ${duration}ms recording...`);
+  console.log('='.repeat(80));
   
   try {
     // Start recording
-    console.log('▶️  Starting recording...');
+    console.log('Starting recording...');
     const { outputPath, startTime } = await startRecording({ 
       fps: 30,
       includeAudio: false 
     });
     
-    console.log(`✅ Recording started at: ${outputPath}`);
+    console.log(`Recording started at: ${outputPath}`);
     
     // Wait for specified duration
-    console.log(`⏳ Recording for ${duration}ms...`);
+    console.log(`Recording for ${duration}ms...`);
     await new Promise(resolve => setTimeout(resolve, duration));
     
     // Stop recording
-    console.log('⏹️  Stopping recording...');
+    console.log('Stopping recording...');
     const result = await stopRecording();
     
-    console.log(`✅ Recording stopped`);
+    console.log(`Recording stopped`);
     console.log(`   Duration: ${result.duration}ms`);
     console.log(`   File: ${result.outputPath}`);
     
@@ -154,15 +154,15 @@ async function testShortRecording(duration = 3000) {
     return result;
     
   } catch (error) {
-    console.error(`❌ Test failed: ${error.message}`);
+    console.error(`Test failed: ${error.message}`);
     console.error(error.stack);
     throw error;
   }
 }
 
 async function testExistingVideo(videoPath) {
-  console.log('\n🔍 Testing existing video...');
-  console.log('═'.repeat(80));
+  console.log('\nTesting existing video...');
+  console.log('='.repeat(80));
   
   return await analyzeVideo(videoPath);
 }
@@ -171,8 +171,8 @@ async function testExistingVideo(videoPath) {
 async function main() {
   const args = process.argv.slice(2);
   
-  console.log('\n🧪 Short Recording Test Suite');
-  console.log('═'.repeat(80));
+  console.log('\nShort Recording Test Suite');
+  console.log('='.repeat(80));
   console.log(`Platform: ${os.platform()}`);
   console.log(`Architecture: ${os.arch()}`);
   console.log(`Node version: ${process.version}`);
@@ -183,13 +183,13 @@ async function main() {
     const result = await testExistingVideo(videoPath);
     
     if (result?.isSingleFrame) {
-      console.log('\n❌ SINGLE-FRAME VIDEO DETECTED!');
+      console.log('\nSINGLE-FRAME VIDEO DETECTED!');
       process.exit(1);
     } else if (result?.hasMissingMetadata) {
-      console.log('\n⚠️  WARNING: Video container metadata is incomplete!');
+      console.log('\nWARNING: Video container metadata is incomplete!');
       console.log('   This can cause playback issues in some players.');
       console.log('   The video has frames but duration is not in the container.');
-      console.log('\n💡 Try fixing it with:');
+      console.log('\nTry fixing it with:');
       console.log(`   node test-short-recording.js fix ${args[1]} ${args[1].replace(/\.(webm|mp4)$/, '-fixed.$1')}`);
       process.exit(1);
     }
@@ -198,38 +198,38 @@ async function main() {
     const inputPath = path.resolve(args[1]);
     const outputPath = path.resolve(args[2]);
     
-    console.log('\n🔧 Fixing video container...');
-    console.log('═'.repeat(80));
+    console.log('\nFixing video container...');
+    console.log('='.repeat(80));
     console.log(`Input:  ${inputPath}`);
     console.log(`Output: ${outputPath}`);
     
     if (!fs.existsSync(inputPath)) {
-      console.error(`❌ Input file does not exist: ${inputPath}`);
+      console.error(`Input file does not exist: ${inputPath}`);
       process.exit(1);
     }
     
     // Analyze before
-    console.log('\n📊 BEFORE:');
+    console.log('\nBEFORE:');
     const beforeResult = await analyzeVideo(inputPath);
     
     // Fix the video
     const fixSuccess = await fixVideoContainer(inputPath, outputPath);
     
     if (!fixSuccess) {
-      console.error('\n❌ Failed to fix video!');
+      console.error('\nFailed to fix video!');
       process.exit(1);
     }
     
     // Analyze after
-    console.log('\n📊 AFTER:');
+    console.log('\nAFTER:');
     const afterResult = await analyzeVideo(outputPath);
     
-    console.log('\n✅ Video fixed successfully!');
-    console.log(`   Before: ${beforeResult?.hasMissingMetadata ? 'Missing metadata ⚠️' : 'Has metadata ✅'}`);
-    console.log(`   After:  ${afterResult?.hasMissingMetadata ? 'Missing metadata ⚠️' : 'Has metadata ✅'}`);
+    console.log('\nVideo fixed successfully!');
+    console.log(`   Before: ${beforeResult?.hasMissingMetadata ? 'Missing metadata' : 'Has metadata'}`);
+    console.log(`   After:  ${afterResult?.hasMissingMetadata ? 'Missing metadata' : 'Has metadata'}`);
     
     if (afterResult?.hasMissingMetadata) {
-      console.log('\n⚠️  Warning: Metadata still missing after fix. The source file may be corrupted.');
+      console.log('\nWarning: Metadata still missing after fix. The source file may be corrupted.');
       process.exit(1);
     }
   } else {
@@ -252,7 +252,7 @@ async function main() {
             fs.unlinkSync(result.snapshotPath);
           }
         } catch (cleanupError) {
-          console.warn(`⚠️  Cleanup warning: ${cleanupError.message}`);
+          console.warn(`Cleanup warning: ${cleanupError.message}`);
         }
       } catch (error) {
         results.push({ duration, success: false, error: error.message });
@@ -263,20 +263,20 @@ async function main() {
     }
     
     // Summary
-    console.log('\n\n📊 TEST SUMMARY');
-    console.log('═'.repeat(80));
+    console.log('\n\nTEST SUMMARY');
+    console.log('='.repeat(80));
     
     for (const result of results) {
-      const status = result.success ? '✅' : '❌';
+      const status = result.success ? 'PASS' : 'FAIL';
       console.log(`${status} ${result.duration}ms recording: ${result.success ? 'PASSED' : result.error}`);
     }
     
     const allPassed = results.every(r => r.success);
     if (!allPassed) {
-      console.log('\n❌ Some tests failed!');
+      console.log('\nSome tests failed!');
       process.exit(1);
     } else {
-      console.log('\n✅ All tests passed!');
+      console.log('\nAll tests passed!');
     }
   }
 }

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