dashcam 1.3.27 → 1.3.29

package/bin/dashcam-background.js

@@ -217,7 +217,7 @@ async function runBackgroundRecording() {
     process.on('SIGINT', () => handleShutdown('SIGINT'));
     process.on('SIGTERM', () => handleShutdown('SIGTERM'));
     
-    // Keep the process alive - wait indefinitely for signals
+    // Keep the process alive - wait indefinitely for SIGKILL from stop command
     logger.info('Background recording is now running. Waiting for stop signal...');
     console.log('[Background] Waiting for stop signal...');
     
@@ -235,7 +235,7 @@ async function runBackgroundRecording() {
     process.exit(1);
   }
   
-  // Infinite loop - process will only exit via signal handlers
+  // Infinite loop - process will only exit via signal handlers or stop file
   await new Promise(() => {});
 }
 

package/bin/dashcam.js

@@ -469,36 +469,63 @@ program
         console.log('Recording stopped successfully');
         logger.debug('Stop result:', result);
         
-        // Wait for background process to write recording result
-        logger.debug('Waiting for recording result from background process...');
-        console.log('Waiting for recording result...');
+        // Reconstruct recording data from status and fix video with FFmpeg
+        console.log('Processing recording...');
+        logger.debug('Reconstructing recording data from status file');
         
-        // Wait up to 30 seconds for recording result to appear
-        const maxWaitForResult = 30000;
-        const startWaitForResult = Date.now();
-        let recordingResult = null;
-        let checkCount = 0;
+        const { fixVideoContainer } = await import('../lib/recorder.js');
+        const { applicationTracker } = await import('../lib/applicationTracker.js');
+        const { logsTrackerManager } = await import('../lib/logs/index.js');
         
-        while (!recordingResult && (Date.now() - startWaitForResult) < maxWaitForResult) {
-          recordingResult = processManager.readRecordingResult();
-          checkCount++;
-          
-          if (!recordingResult) {
-            if (checkCount % 5 === 0) {
-              const elapsed = Math.round((Date.now() - startWaitForResult) / 1000);
-              console.log(`Waiting for recording result... (${elapsed}s)`);
-            }
-            await new Promise(resolve => setTimeout(resolve, 1000));
+        // Get temp file path
+        const tempFileInfoPath = path.join(os.tmpdir(), 'dashcam', 'temp-file.json');
+        let tempFileInfo = null;
+        try {
+          tempFileInfo = JSON.parse(fs.readFileSync(tempFileInfoPath, 'utf8'));
+        } catch (error) {
+          logger.error('Failed to read temp file info', { error });
+        }
+        
+        const tempFile = tempFileInfo?.tempFile || result.outputPath.replace('.webm', '-temp.webm');
+        const outputPath = result.outputPath;
+        
+        // Fix the video with FFmpeg (handle incomplete recordings)
+        logger.info('Fixing video with FFmpeg', { tempFile, outputPath });
+        if (fs.existsSync(tempFile)) {
+          try {
+            await fixVideoContainer(tempFile, outputPath);
+            logger.info('Video fixed successfully');
+          } catch (error) {
+            logger.warn('FFmpeg fix failed, using temp file as-is', { error: error.message });
+            // If fix fails, just copy the temp file
+            fs.copyFileSync(tempFile, outputPath);
           }
+        } else {
+          logger.warn('Temp file not found, using output path directly', { tempFile });
         }
         
+        // Collect application and log data
+        const apps = await applicationTracker.getApps(activeStatus.startTime);
+        const logs = await logsTrackerManager.getLogsForRecording();
+        
+        const recordingResult = {
+          outputPath,
+          duration: result.duration,
+          clientStartDate: activeStatus.startTime,
+          apps,
+          logs,
+          title: activeStatus?.options?.title,
+          description: activeStatus?.options?.description,
+          project: activeStatus?.options?.project
+        };
+        
         if (!recordingResult || !recordingResult.outputPath) {
-          console.error('Failed to get recording result from background process');
-          logger.error('No recording result received', { recordingResult });
+          console.error('Failed to process recording');
+          logger.error('No recording result', { recordingResult });
           process.exit(1);
         }
         
-        console.log('Recording result received, uploading...');
+        console.log('Uploading recording...');
         logger.debug('Recording result:', recordingResult);
         
         try {

package/lib/processManager.js

@@ -11,7 +11,7 @@ const __dirname = path.dirname(__filename);
 // Use user home directory for cross-session communication
 const PROCESS_DIR = path.join(os.homedir(), '.dashcam-cli');
 const STATUS_FILE = path.join(PROCESS_DIR, 'status.json');
-const RESULT_FILE = path.join(PROCESS_DIR, 'recording-result.json');
+const RECORDING_RESULT_FILE = path.join(PROCESS_DIR, 'recording-result.json');
 
 console.log('[INIT] Process Manager initialized');
 console.log('[INIT] Process directory:', PROCESS_DIR);
@@ -281,36 +281,33 @@ class ProcessManager {
         return false;
       }
       
-      logger.info('Sending stop signal to background process', { pid });
+      logger.info('Killing background process', { pid });
       
-      // Send SIGTERM to the background process to trigger graceful shutdown
+      // Kill the process immediately - no graceful shutdown needed
+      // Video is already being streamed to disk, we'll fix it with FFmpeg
       try {
-        process.kill(pid, 'SIGTERM');
-        logger.info('Sent SIGTERM to background process');
+        process.kill(pid, 'SIGKILL');
+        logger.info('Sent SIGKILL to background process');
       } catch (error) {
-        logger.error('Failed to send signal to background process', { error });
+        logger.error('Failed to kill background process', { error });
         throw new Error('Failed to stop background recording process');
       }
       
-      // Wait for the background process to finish and write results
-      logger.debug('Waiting for background process to complete...');
-      const maxWaitTime = 30000; // 30 seconds
+      // Wait briefly for process to die
+      logger.debug('Waiting for background process to exit...');
+      const maxWaitTime = 5000; // 5 seconds should be plenty for SIGKILL
       const startWait = Date.now();
       
       while (this.isProcessRunning(pid) && (Date.now() - startWait) < maxWaitTime) {
-        await new Promise(resolve => setTimeout(resolve, 500));
+        await new Promise(resolve => setTimeout(resolve, 100));
       }
       
       if (this.isProcessRunning(pid)) {
-        logger.error('Background process did not exit within timeout, forcing kill');
-        try {
-          process.kill(pid, 'SIGKILL');
-        } catch (error) {
-          logger.error('Failed to force kill background process', { error });
-        }
+        logger.error('Background process did not exit after SIGKILL');
+        throw new Error('Failed to kill background process');
       }
       
-      logger.info('Background process stopped');
+      logger.info('Background process killed');
       
       // Mark status as completed
       this.markStatusCompleted({ 

package/package.json

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