dashcam 1.4.0-beta → 1.4.1-beta

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';
@@ -536,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...');
@@ -546,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
 
@@ -571,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
@@ -592,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)
@@ -641,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.4.0-beta",
+  "version": "1.4.1-beta",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/dashcam.js",
   "bin": {