dashcam 1.4.1-beta → 1.4.3-beta

package/bin/dashcam-background.js

@@ -161,11 +161,39 @@ async function runBackgroundRecording() {
       }
       isShuttingDown = true;
       
-      logger.info(`Received ${signal}, background process will be killed`);
-      console.log('[Background] Received stop signal, process will be terminated...');
+      logger.info(`Received ${signal}, cleaning up child processes`);
+      console.log('[Background] Received stop signal, cleaning up...');
+      
+      // Kill any child processes (ffmpeg, etc.)
+      try {
+        // Get all child processes and kill them
+        const { exec } = await import('child_process');
+        const platform = process.platform;
+        
+        if (platform === 'darwin' || platform === 'linux') {
+          // On Unix, kill the entire process group
+          exec(`pkill -P ${process.pid}`, (error) => {
+            if (error && error.code !== 1) { // code 1 means no processes found
+              logger.warn('Failed to kill child processes', { error: error.message });
+            }
+            logger.info('Child processes killed');
+          });
+        } else if (platform === 'win32') {
+          // On Windows, use taskkill
+          exec(`taskkill /F /T /PID ${process.pid}`, (error) => {
+            if (error) {
+              logger.warn('Failed to kill child processes on Windows', { error: error.message });
+            }
+            logger.info('Child processes killed');
+          });
+        }
+        
+        // Give it a moment to clean up
+        await new Promise(resolve => setTimeout(resolve, 500));
+      } catch (error) {
+        logger.error('Error during cleanup', { error: error.message });
+      }
       
-      // 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);
     };

package/bin/dashcam.js

@@ -622,14 +622,33 @@ program
             const { jsonl } = await import('../lib/utilities/jsonl.js');
             const webLogs = jsonl.read(webLogsFile);
             if (webLogs && webLogs.length > 0) {
+              // Load web config to get patterns
+              const webConfigFile = path.join(process.cwd(), '.dashcam', 'web-config.json');
+              let webPatterns = ['*']; // Default to all patterns
+              if (fs.existsSync(webConfigFile)) {
+                try {
+                  const webConfig = JSON.parse(fs.readFileSync(webConfigFile, 'utf8'));
+                  // Extract all patterns from all enabled configs
+                  webPatterns = Object.values(webConfig)
+                    .filter(config => config.enabled !== false)
+                    .flatMap(config => config.patterns || []);
+                  if (webPatterns.length === 0) {
+                    webPatterns = ['*'];
+                  }
+                } catch (error) {
+                  logger.warn('Failed to load web config for patterns', { error: error.message });
+                }
+              }
+              
               logTrackingResults.push({
                 type: 'web',
                 name: 'Web Logs',
                 fileLocation: webLogsFile,
                 count: webLogs.length,
-                trimmedFileLocation: webLogsFile
+                trimmedFileLocation: webLogsFile,
+                patterns: webPatterns // Include patterns for filtering
               });
-              logger.info('Found web logs', { count: webLogs.length, file: webLogsFile });
+              logger.info('Found web logs', { count: webLogs.length, file: webLogsFile, patterns: webPatterns });
             }
           }
           
@@ -719,6 +738,7 @@ program
   .option('--remove <id>', 'Remove a log tracker by ID')
   .option('--list', 'List all configured log trackers')
   .option('--status', 'Show log tracking status')
+  .option('--view [directory]', 'View logs from recording directory (defaults to most recent in /tmp/dashcam/recordings)')
   .option('--name <name>', 'Name for the log tracker (required with --add)')
   .option('--type <type>', 'Type of tracker: "web" or "file" (required with --add)')
   .option('--pattern <pattern>', 'Pattern to track (can be used multiple times)', (value, previous) => {
@@ -812,6 +832,16 @@ program
         console.log(`  File trackers: ${status.cliFilesCount}`);
         console.log(`  Web trackers: ${status.webAppsCount}`);
         console.log(`  Total recent events: ${status.totalEvents}`);
+        console.log(`  Web daemon running: ${status.webDaemonRunning ? 'Yes' : 'No'}`);
+        
+        // Show WebSocket server info
+        const { server } = await import('../lib/websocket/server.js');
+        if (server.isListening.value) {
+          console.log(`  WebSocket server: Listening on port ${server.port}`);
+          console.log(`  WebSocket clients: ${server._socket?.clients?.size || 0} connected`);
+        } else {
+          console.log(`  WebSocket server: Not listening`);
+        }
         
         if (status.fileTrackerStats.length > 0) {
           console.log('\n  File tracker activity (last minute):');
@@ -819,13 +849,127 @@ program
             console.log(`    ${stat.filePath}: ${stat.count} events`);
           });
         }
+        
+        if (status.webApps.length > 0) {
+          console.log('\n  Web tracker patterns:');
+          status.webApps.forEach(app => {
+            console.log(`    ${app.name}: ${app.patterns.join(', ')}`);
+          });
+        }
+      } else if (options.view !== undefined) {
+        // View logs from a recording directory
+        const { jsonl } = await import('../lib/utilities/jsonl.js');
+        
+        let targetDir = options.view;
+        
+        // If no directory specified, find the most recent recording directory
+        if (!targetDir || targetDir === true) {
+          const recordingsDir = path.join(os.tmpdir(), 'dashcam', 'recordings');
+          if (!fs.existsSync(recordingsDir)) {
+            console.error('No recordings directory found at:', recordingsDir);
+            process.exit(1);
+          }
+          
+          const entries = fs.readdirSync(recordingsDir, { withFileTypes: true });
+          const dirs = entries
+            .filter(entry => entry.isDirectory())
+            .map(entry => ({
+              name: entry.name,
+              path: path.join(recordingsDir, entry.name),
+              mtime: fs.statSync(path.join(recordingsDir, entry.name)).mtime
+            }))
+            .sort((a, b) => b.mtime - a.mtime);
+          
+          if (dirs.length === 0) {
+            console.error('No recording directories found in:', recordingsDir);
+            process.exit(1);
+          }
+          
+          targetDir = dirs[0].path;
+          console.log('Viewing logs from most recent recording:', path.basename(targetDir));
+        } else if (!fs.existsSync(targetDir)) {
+          console.error('Directory does not exist:', targetDir);
+          process.exit(1);
+        }
+        
+        console.log('Directory:', targetDir);
+        console.log('');
+        
+        // Check for CLI logs
+        const cliLogsFile = path.join(targetDir, 'dashcam_logs_cli.jsonl');
+        if (fs.existsSync(cliLogsFile)) {
+          const cliLogs = jsonl.read(cliLogsFile);
+          if (cliLogs && cliLogs.length > 0) {
+            console.log(`📄 CLI Logs (${cliLogs.length} events):`);
+            cliLogs.slice(0, 50).forEach((log, index) => {
+              const timeSeconds = ((log.time || 0) / 1000).toFixed(2);
+              const logFile = log.logFile || 'unknown';
+              const content = (log.line || log.content || '').substring(0, 100);
+              console.log(`  [${timeSeconds}s] ${logFile}: ${content}`);
+            });
+            if (cliLogs.length > 50) {
+              console.log(`  ... and ${cliLogs.length - 50} more events`);
+            }
+            console.log('');
+          }
+        } else {
+          console.log('📄 CLI Logs: No logs found');
+          console.log('');
+        }
+        
+        // Check for web logs
+        const webLogsFile = path.join(targetDir, 'dashcam_logs_web_events.jsonl');
+        if (fs.existsSync(webLogsFile)) {
+          const webLogs = jsonl.read(webLogsFile);
+          if (webLogs && webLogs.length > 0) {
+            console.log(`🌐 Web Logs (${webLogs.length} events):`);
+            
+            // Group by event type
+            const eventTypes = {};
+            webLogs.forEach(log => {
+              eventTypes[log.type] = (eventTypes[log.type] || 0) + 1;
+            });
+            
+            console.log('  Event types:');
+            Object.entries(eventTypes).forEach(([type, count]) => {
+              console.log(`    ${type}: ${count}`);
+            });
+            console.log('');
+            
+            // Show first 20 events
+            console.log('  Recent events:');
+            webLogs.slice(0, 20).forEach((log, index) => {
+              const timeSeconds = ((log.time || 0) / 1000).toFixed(2);
+              const type = log.type || 'unknown';
+              
+              if (type === 'LOG_EVENT' || type === 'LOG_ERROR') {
+                const message = log.payload?.message || '';
+                console.log(`  [${timeSeconds}s] ${type}: ${message.substring(0, 80)}`);
+              } else if (type.startsWith('NETWORK_')) {
+                const url = log.payload?.url || '';
+                console.log(`  [${timeSeconds}s] ${type}: ${url.substring(0, 80)}`);
+              } else {
+                console.log(`  [${timeSeconds}s] ${type}`);
+              }
+            });
+            if (webLogs.length > 20) {
+              console.log(`  ... and ${webLogs.length - 20} more events`);
+            }
+            console.log('');
+          }
+        } else {
+          console.log('🌐 Web Logs: No logs found');
+          console.log('');
+        }
       } else {
-        console.log('Please specify an action: --add, --remove, --list, or --status');
+        console.log('Please specify an action: --add, --remove, --list, --status, or --view');
         console.log('\nExamples:');
         console.log('  dashcam logs --add --name=social --type=web --pattern="*facebook.com*" --pattern="*twitter.com*"');
         console.log('  dashcam logs --add --name=app-logs --type=file --file=/var/log/app.log');
         console.log('  dashcam logs --list');
         console.log('  dashcam logs --status');
+        console.log('  dashcam logs --view                    # View logs from most recent recording');
+        console.log('  dashcam logs --view /path/to/recording # View logs from specific directory');
         console.log('\nUse "dashcam logs --help" for more information');
       }
       

package/lib/extension-logs/helpers.js

@@ -84,7 +84,13 @@ function filterWebEvents(
     event => event.type === 'INITIAL_TABS' || event.payload.tabId
   );
   const patterns = groupLogsStatuses
-    .map((status) => status.items.map((item) => item.item))
+    .map((status) => {
+      // Handle cases where items might not be set (e.g., during upload)
+      if (!status.items || !Array.isArray(status.items)) {
+        return status.patterns || [];
+      }
+      return status.items.map((item) => item.item);
+    })
     .flat();
 
   const newEvents = [];

package/lib/logs/index.js

@@ -123,7 +123,11 @@ async function trimLogs(groupLogStatuses, startMS, endMS, clientStartDate, clipI
         filteredEvents
       );
     } catch (error) {
-      logger.error('Error trimming log file', { file: status.fileLocation, error });
+      logger.error('Error trimming log file', { 
+        file: status.fileLocation, 
+        error: error.message,
+        stack: error.stack
+      });
     }
   });
 

package/lib/processManager.js

@@ -283,31 +283,50 @@ class ProcessManager {
       
       logger.info('Killing background process', { pid });
       
-      // Kill the process immediately - no graceful shutdown needed
-      // Video is already being streamed to disk, we'll fix it with FFmpeg
+      // Try graceful shutdown first with SIGTERM (allows cleanup handlers to run)
+      // Then use SIGKILL if process doesn't exit
       try {
-        process.kill(pid, 'SIGKILL');
-        logger.info('Sent SIGKILL to background process');
+        process.kill(pid, 'SIGTERM');
+        logger.info('Sent SIGTERM to background process');
       } catch (error) {
-        logger.error('Failed to kill background process', { error });
+        logger.error('Failed to send SIGTERM to background process', { error });
         throw new Error('Failed to stop background recording process');
       }
       
-      // Wait briefly for process to die
-      logger.debug('Waiting for background process to exit...');
-      const maxWaitTime = 5000; // 5 seconds should be plenty for SIGKILL
+      // Wait for graceful shutdown
+      logger.debug('Waiting for background process to exit gracefully...');
+      const maxGracefulWait = 3000; // 3 seconds for graceful shutdown
       const startWait = Date.now();
       
-      while (this.isProcessRunning(pid) && (Date.now() - startWait) < maxWaitTime) {
+      while (this.isProcessRunning(pid) && (Date.now() - startWait) < maxGracefulWait) {
         await new Promise(resolve => setTimeout(resolve, 100));
       }
       
+      // If still running, force kill with SIGKILL
       if (this.isProcessRunning(pid)) {
-        logger.error('Background process did not exit after SIGKILL');
-        throw new Error('Failed to kill background process');
+        logger.warn('Background process did not exit gracefully, sending SIGKILL');
+        try {
+          process.kill(pid, 'SIGKILL');
+          logger.info('Sent SIGKILL to background process');
+          
+          // Wait for SIGKILL to take effect
+          const maxKillWait = 2000; // 2 seconds should be plenty for SIGKILL
+          const killStart = Date.now();
+          while (this.isProcessRunning(pid) && (Date.now() - killStart) < maxKillWait) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+          }
+          
+          if (this.isProcessRunning(pid)) {
+            logger.error('Background process did not exit even after SIGKILL');
+            throw new Error('Failed to kill background process');
+          }
+        } catch (error) {
+          logger.error('Failed to SIGKILL background process', { error });
+          throw new Error('Failed to force kill background process');
+        }
       }
       
-      logger.info('Background process killed');
+      logger.info('Background process stopped');
       
       // Mark status as completed
       this.markStatusCompleted({ 

package/lib/recorder.js

@@ -320,8 +320,14 @@ export async function startRecording({
   
   // Construct FFmpeg command arguments
   const platformArgs = await getPlatformArgs({ fps, includeAudio });
+  
+  // Detect platform for encoder settings
+  const platform = os.platform();
+  const isWindows = platform === 'win32';
 
   const outputArgs = [
+    // Convert pixel format first to handle transparency issues on Windows
+    '-pix_fmt', 'yuv420p',  // Force YUV420P format (no alpha channel)
     '-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)
@@ -330,6 +336,7 @@ export async function startRecording({
     '-r', fps.toString(),   // Ensure output framerate matches input
     '-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
+    '-auto-alt-ref', '0',   // Disable auto alternate reference frames (fixes transparency encoding error)
     // 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
@@ -407,19 +414,12 @@ export async function startRecording({
       reject: false,
       all: true, // Capture both stdout and stderr
       stdin: 'pipe', // Enable stdin for sending 'q' to stop recording
-      detached: false,
+      detached: false, // Keep attached so it dies with parent
       windowsHide: true // Hide the console window on Windows
     });
     
-    // Unref the child process so it doesn't keep the parent alive
-    if (currentRecording.pid) {
-      try {
-        currentRecording.unref();
-      } catch (e) {
-        // Ignore errors if unref is not available
-        logger.debug('Could not unref ffmpeg process');
-      }
-    }
+    // Don't unref - we want FFmpeg to be killed when parent dies
+    // Removing unref() ensures orphaned processes don't hang around
     
     logger.info('FFmpeg process spawned', { 
       pid: currentRecording.pid,

package/lib/utilities/jsonl.js

@@ -62,14 +62,23 @@ export const jsonl = {
         let fd = fs.openSync(file, 'w');
         fs.closeSync(fd);
       } catch (error) {
-        throttledLog('info', `jsonl.js failed to initialize file ${error}`);
+        throttledLog('info', `jsonl.js failed to initialize file ${error.message}`, {
+          directory,
+          fileName,
+          error: error.message
+        });
+        throw error;
       }
     }
     try {
       let data = arrayOfJsonObjects.map((x) => JSON.stringify(x)).join('\n');
       fs.writeFileSync(file, data);
     } catch (error) {
-      throttledLog('info', `jsonl.js failed to write to file ${error}`);
+      throttledLog('info', `jsonl.js failed to write to file ${error.message}`, {
+        file,
+        error: error.message
+      });
+      throw error;
     }
 
     return file;

package/lib/websocket/server.js

@@ -51,7 +51,7 @@ class WSServer {
       return;
     }
     
-    logger.debug('WebSocketServer: Starting server, trying ports...', { ports: this.ports });
+    logger.info('WebSocketServer: Starting server, trying ports...', { ports: this.ports });
     for (const port of this.ports) {
       const ws = await new Promise((resolve) => {
         logger.debug('WebSocketServer: Trying port ' + port);
@@ -104,7 +104,11 @@ class WSServer {
     });
 
     this.#socket.on('connection', (client) => {
-      logger.info('WebSocketServer: New client connection established');
+      logger.info('WebSocketServer: New client connection established', {
+        clientAddress: client._socket?.remoteAddress,
+        clientPort: client._socket?.remotePort,
+        totalClients: this.#socket.clients.size
+      });
       
       let state = states.NEW;
       const failValidation = () => {
@@ -124,17 +128,22 @@ class WSServer {
 
       client.on('message', (data, isBinary) => {
         let message = isBinary ? data : data.toString();
-        logger.debug('WebSocketServer: Received message from client', { 
+        logger.info('WebSocketServer: Received message from client', { 
           isBinary, 
           messageLength: message.length,
+          messagePreview: message.substring(0, 100),
           state 
         });
         
         try {
           message = JSON.parse(message);
-          logger.debug('WebSocketServer: Parsed message', { type: message.type, hasPayload: !!message.payload });
+          logger.info('WebSocketServer: Parsed message', { 
+            type: message.type, 
+            hasPayload: !!message.payload,
+            payloadKeys: message.payload ? Object.keys(message.payload) : []
+          });
         } catch (err) {
-          logger.debug('WebSocketServer: Message is not JSON, treating as raw string');
+          logger.info('WebSocketServer: Message is not JSON, treating as raw string', { rawMessage: message });
         }
         
         if (state === states.SENT_HEADERS) {
@@ -152,14 +161,14 @@ class WSServer {
         this.emit('message', message, client);
       });
 
-      logger.debug('WebSocketServer: Sending connection header to client');
+      logger.info('WebSocketServer: Sending connection header to client');
       client.send('dashcam_desktop_socket_connected', (err) => {
         if (err) {
           logger.error('WebSocketServer: Failed to send connection header', { error: err.message });
           client.close();
           clearTimeout(timeout);
         } else {
-          logger.debug('WebSocketServer: Connection header sent, waiting for confirmation');
+          logger.info('WebSocketServer: Connection header sent, waiting for confirmation');
           state = states.SENT_HEADERS;
         }
       });
@@ -176,9 +185,10 @@ class WSServer {
       throw new Error('Server not currently running');
     }
     
-    logger.debug('WebSocketServer: Broadcasting message to all clients', { 
+    logger.info('WebSocketServer: Broadcasting message to all clients', { 
       clientCount: this.#socket.clients.size,
-      messageType: message.type || 'raw'
+      messageType: message.type || 'raw',
+      messagePayload: message.payload ? JSON.stringify(message.payload).substring(0, 100) : 'none'
     });
     
     this.#socket.clients.forEach((client) => {

package/package.json

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

package/test_workflow.sh

@@ -21,11 +21,13 @@ echo "✅ Web tracking configured"
 echo ""
 echo "3. Setting up file tracking..."
 TEMP_FILE="/tmp/test-cli-log.txt"
-echo "Using existing test file: $TEMP_FILE"
 
-# File is already tracked from previous tests, check if it exists
-if [ ! -f "$TEMP_FILE" ]; then
-  touch "$TEMP_FILE"
+# Clear the file to start fresh (remove old events from previous test runs)
+> "$TEMP_FILE"
+echo "Created fresh test file: $TEMP_FILE"
+
+# File is already tracked from previous tests, check if it exists in config
+if ! ./bin/dashcam.js logs --list 2>/dev/null | grep -q "$TEMP_FILE"; then
   ./bin/dashcam.js logs --add --name=temp-file-tracking --type=file --file="$TEMP_FILE"
 fi
 echo "✅ File tracking configured"