node-mac-recorder 2.21.37 → 2.21.40

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.21.37",
+	"version": "2.21.40",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [

package/src/avfoundation_recorder.mm

@@ -282,41 +282,18 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             }
         }
 
-        // ELECTRON SAFETY: Test image capture BEFORE starting timer
-        // This prevents crash if display capture doesn't work
-        MRLog(@"🧪 Testing display capture before starting timer...");
-        CGImageRef testCapture = CGDisplayCreateImage(g_avDisplayID);
-        if (!testCapture) {
-            NSLog(@"❌ CRITICAL: Cannot capture display %u - aborting", g_avDisplayID);
-            if (g_avWriter) {
-                [g_avWriter cancelWriting];
-                g_avWriter = nil;
-            }
-            return false;
-        }
-        CGImageRelease(testCapture);
-        MRLog(@"✅ Display capture test successful");
-
         // Start capture timer using target FPS
-        // ELECTRON SAFETY: Use a dedicated serial queue to avoid main thread conflicts
         dispatch_queue_t captureQueue = dispatch_queue_create("AVFoundationCaptureQueue", DISPATCH_QUEUE_SERIAL);
-        dispatch_set_target_queue(captureQueue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0));
-
         g_avTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, captureQueue);
-
+        
         if (!g_avTimer) {
             NSLog(@"❌ Failed to create dispatch timer");
-            if (g_avWriter) {
-                [g_avWriter cancelWriting];
-                g_avWriter = nil;
-            }
             return false;
         }
-
+        
         uint64_t interval = (uint64_t)(NSEC_PER_SEC / fps);
-        // ELECTRON SAFETY: Add small delay before first frame (100ms)
-        dispatch_source_set_timer(g_avTimer, dispatch_time(DISPATCH_TIME_NOW, 100 * NSEC_PER_MSEC), interval, interval / 10);
-
+        dispatch_source_set_timer(g_avTimer, dispatch_time(DISPATCH_TIME_NOW, 0), interval, interval / 10);
+        
         // Retain objects before passing to block to prevent deallocation
         AVAssetWriterInput *localVideoInput = g_avVideoInput;
         AVAssetWriterInputPixelBufferAdaptor *localPixelBufferAdaptor = g_avPixelBufferAdaptor;
@@ -471,25 +448,12 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                 }
             }
         });
-
-        // ELECTRON SAFETY: Start timer with exception handling
-        @try {
-            // Set recording flag BEFORE resuming timer
-            g_avIsRecording = true;
-
-            dispatch_resume(g_avTimer);
-
-            MRLog(@"🎥 AVFoundation recording started: %dx%d @ %.0ffps",
-                  (int)recordingSize.width, (int)recordingSize.height, fps);
-        } @catch (NSException *exception) {
-            NSLog(@"❌ Failed to start timer: %@", exception.reason);
-            g_avIsRecording = false;
-            if (g_avTimer) {
-                dispatch_source_cancel(g_avTimer);
-                g_avTimer = nil;
-            }
-            return false;
-        }
+        
+        dispatch_resume(g_avTimer);
+        g_avIsRecording = true;
+        
+        MRLog(@"🎥 AVFoundation recording started: %dx%d @ %.0ffps", 
+              (int)recordingSize.width, (int)recordingSize.height, fps);
         
         return true;
         
@@ -526,8 +490,14 @@ extern "C" bool stopAVFoundationRecording() {
             // Mark as not recording FIRST to stop timer callbacks
             g_avIsRecording = false;
             
-            // Cancel timer immediately (Electron-safe)
+            // Cancel timer and wait a brief moment for completion
             dispatch_source_cancel(g_avTimer);
+            
+            // Use async to avoid deadlock in Electron
+            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 100 * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{
+                // Timer should be fully cancelled by now
+            });
+            
             g_avTimer = nil;
             MRLog(@"✅ AVFoundation timer stopped safely");
         }
@@ -540,16 +510,13 @@ extern "C" bool stopAVFoundationRecording() {
         
         AVAssetWriter *writer = g_avWriter;
         if (writer && writer.status == AVAssetWriterStatusWriting) {
-            // ELECTRON SAFETY: Don't use dispatch_semaphore_wait - causes crashes in Electron
-            // Just call finishWriting async and let it complete in background
+            dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
             [writer finishWritingWithCompletionHandler:^{
-                if (writer.status == AVAssetWriterStatusCompleted) {
-                    MRLog(@"✅ AVFoundation writer finished successfully");
-                } else if (writer.error) {
-                    NSLog(@"⚠️ AVFoundation writer error: %@", writer.error);
-                }
+                dispatch_semaphore_signal(semaphore);
             }];
-            MRLog(@"🔄 AVFoundation writer finishing asynchronously (Electron-safe mode)");
+            // Add timeout to prevent infinite wait in Electron
+            dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC);
+            dispatch_semaphore_wait(semaphore, timeout);
         }
         
         // Cleanup

package/src/camera_recorder.mm

@@ -922,15 +922,9 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
             if (CMTIME_IS_VALID(baseline)) {
                 frameSeconds = CMTimeGetSeconds(CMTimeSubtract(bufferTime, baseline));
             }
-            // Adjust camera stop limit by start offset relative to audio
+            // Do NOT extend camera stop limit by audio start offset.
+            // Clamping to the same stopLimit as audio ensures durations match.
             double effectiveStopLimit = stopLimit;
-            if (hasAudioStart && CMTIME_IS_VALID(baseline)) {
-                CMTime startDeltaTime = CMTimeSubtract(baseline, audioStart);
-                double startDelta = CMTimeGetSeconds(startDeltaTime);
-                if (startDelta > 0) {
-                    effectiveStopLimit += startDelta;
-                }
-            }
             double tolerance = self.expectedFrameRate > 0 ? (1.5 / self.expectedFrameRate) : 0.02;
             if (tolerance < 0.02) {
                 tolerance = 0.02;
@@ -1022,16 +1016,8 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
 
     double stopLimit = MRSyncGetStopLimitSeconds();
     if (stopLimit > 0) {
-        // Adjust by camera start vs audio start so durations align closely
-        CMTime audioStartTS = MRSyncAudioFirstTimestamp();
-        if (CMTIME_IS_VALID(audioStartTS) && CMTIME_IS_VALID(self.firstSampleTime)) {
-            CMTime startDeltaTS = CMTimeSubtract(self.firstSampleTime, audioStartTS);
-            double startDelta = CMTimeGetSeconds(startDeltaTS);
-            if (startDelta > 0) {
-                stopLimit += startDelta;
-            }
-        }
-
+        // Do NOT extend camera stop limit by audio start offset.
+        // Using the same stopLimit as audio keeps durations aligned.
         double frameSeconds = CMTimeGetSeconds(relativeTimestamp);
         double tolerance = self.expectedFrameRate > 0 ? (1.5 / self.expectedFrameRate) : 0.02;
         if (tolerance < 0.02) {

package/src/mac_recorder.mm

@@ -137,22 +137,29 @@ static bool startAudioIfRequested(bool captureAudio,
 }
 
 // Helper function to cleanup recording resources
-// CRITICAL FIX: Made safer for Electron - only resets state flags, doesn't call stop
-// Calling stop operations during startup causes crashes in Electron
 void cleanupRecording() {
-    // ELECTRON SAFETY: Don't call stop operations here - they're async and cause crashes
-    // Just reset state flags if they're stuck
-
-    @try {
-        // Only reset flags, don't actually stop anything
-        g_isRecording = false;
-        g_usingStandaloneAudio = false;
-        MRSyncConfigure(NO);
+    // ScreenCaptureKit cleanup
+    if (@available(macOS 12.3, *)) {
+        if ([ScreenCaptureKitRecorder isRecording]) {
+            [ScreenCaptureKitRecorder stopRecording];
+        }
+    }
+    
+    // AVFoundation cleanup (supports both Node.js and Electron)
+    if (isAVFoundationRecording()) {
+        stopAVFoundationRecording();
+    }
 
-        MRLog(@"🧹 State flags reset (safe mode - no actual stop operations)");
-    } @catch (NSException *exception) {
-        NSLog(@"⚠️ Exception during state reset: %@", exception.reason);
+    if (isCameraRecording()) {
+        stopCameraRecording();
     }
+    if (isStandaloneAudioRecording()) {
+        stopStandaloneAudioRecording();
+    }
+    g_usingStandaloneAudio = false;
+    
+    g_isRecording = false;
+    MRSyncConfigure(NO);
 }
 
 // NAPI Function: Start Recording
@@ -164,16 +171,24 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         return env.Null();
     }
     
-    // ELECTRON SAFETY: Just check if recording is active, don't try to clean up
-    // Cleanup operations during start cause crashes in Electron
+    // IMPORTANT: Clean up any stale recording state before starting
+    // This fixes the issue where macOS 14/13 users get "recording already in progress"
+    MRLog(@"🧹 Cleaning up any previous recording state...");
+    cleanupRecording();
+
     if (g_isRecording) {
-        MRLog(@"⚠️ Recording already in progress");
+        MRLog(@"⚠️ Still recording after cleanup - forcing stop");
         return Napi::Boolean::New(env, false);
     }
 
-    // ELECTRON SAFETY: Reset state flags in case they're stuck
-    MRLog(@"🧹 Resetting state flags (safe mode)...");
-    cleanupRecording();  // This now only resets flags, doesn't call stop operations
+    // CRITICAL FIX: Check if ScreenCaptureKit is still cleaning up (async stop in progress)
+    if (@available(macOS 12.3, *)) {
+        extern BOOL isScreenCaptureKitCleaningUp();
+        if (isScreenCaptureKitCleaningUp()) {
+            MRLog(@"⚠️ ScreenCaptureKit is still stopping previous recording - please wait");
+            return Napi::Boolean::New(env, false);
+        }
+    }
     g_usingStandaloneAudio = false;
     
     std::string outputPath = info[0].As<Napi::String>().Utf8Value();
@@ -362,23 +377,23 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         MRLog(@"🖥️ macOS Version: %ld.%ld.%ld",
               (long)osVersion.majorVersion, (long)osVersion.minorVersion, (long)osVersion.patchVersion);
 
-        // CRITICAL FIX FOR ELECTRON: ScreenCaptureKit crashes in Electron on macOS 15+
-        // Force AVFoundation for Electron regardless of macOS version
-        BOOL forceAVFoundation = isElectron ? YES : NO;
-
         if (isElectron) {
             MRLog(@"⚡ Electron environment detected");
-            MRLog(@"🔧 FORCING AVFoundation for Electron stability (ScreenCaptureKit crashes in Electron)");
-            forceAVFoundation = YES;  // CRITICAL: ScreenCaptureKit is unstable in Electron
+            MRLog(@"🔧 CRITICAL FIX: Forcing AVFoundation for Electron stability");
+            MRLog(@"   Reason: ScreenCaptureKit has thread safety issues in Electron (SIGTRAP crashes)");
         }
 
-        MRLog(@"🔧 FRAMEWORK SELECTION: Smart selection based on macOS version");
+        // CRITICAL FIX: Always use AVFoundation for stability
+        // ScreenCaptureKit has file writing issues in Node.js environment
+        // AVFoundation works reliably in both Node.js and Electron
+        BOOL forceAVFoundation = YES;
+
+        MRLog(@"🔧 FRAMEWORK SELECTION: Using AVFoundation for stability");
         MRLog(@"   Environment: %@", isElectron ? @"Electron" : @"Node.js");
         MRLog(@"   macOS: %ld.%ld.%ld", (long)osVersion.majorVersion, (long)osVersion.minorVersion, (long)osVersion.patchVersion);
 
-        // Electron-first priority: Both frameworks fully supported in Electron
-        // macOS 15+: Try ScreenCaptureKit first (better performance)
-        // macOS 14/13: Use AVFoundation (ScreenCaptureKit not available)
+        // Electron-first priority: ALWAYS use AVFoundation in Electron for stability
+        // ScreenCaptureKit has severe thread safety issues in Electron causing SIGTRAP crashes
         if (isM15Plus && !forceAVFoundation) {
             if (isElectron) {
                 MRLog(@"⚡ ELECTRON PRIORITY: macOS 15+ Electron → ScreenCaptureKit with full support");
@@ -590,41 +605,30 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     
     // Try ScreenCaptureKit first
     if (@available(macOS 12.3, *)) {
-        @try {
-            if ([ScreenCaptureKitRecorder isRecording]) {
-                MRLog(@"🛑 Stopping ScreenCaptureKit recording");
+        if ([ScreenCaptureKitRecorder isRecording]) {
+            MRLog(@"🛑 Stopping ScreenCaptureKit recording");
 
-                // ELECTRON SAFETY: Stop camera without waiting
-                if (isCameraRecording()) {
-                    MRLog(@"🛑 Stopping camera recording...");
-                    @try {
-                        stopCameraRecording();
-                        MRLog(@"✅ Camera stop dispatched");
-                    } @catch (NSException *exception) {
-                        NSLog(@"⚠️ Camera stop exception: %@", exception.reason);
-                    }
+            // CRITICAL FIX: Stop camera and audio FIRST (they are synchronous)
+            if (isCameraRecording()) {
+                MRLog(@"🛑 Stopping camera recording...");
+                bool cameraStopped = stopCameraRecording();
+                if (cameraStopped) {
+                    MRLog(@"✅ Camera stopped successfully");
+                } else {
+                    MRLog(@"⚠️ Camera stop may have timed out");
                 }
+            }
 
-                // Now stop ScreenCaptureKit (asynchronous)
-                // WARNING: [ScreenCaptureKitRecorder stopRecording] is ASYNC!
-                @try {
-                    [ScreenCaptureKitRecorder stopRecording];
-                    MRLog(@"✅ ScreenCaptureKit stop dispatched");
-                } @catch (NSException *exception) {
-                    NSLog(@"❌ ScreenCaptureKit stop exception: %@", exception.reason);
-                    g_isRecording = false;
-                    return Napi::Boolean::New(env, false);
-                }
+            // Now stop ScreenCaptureKit (asynchronous)
+            // WARNING: [ScreenCaptureKitRecorder stopRecording] is ASYNC!
+            // It will set g_isRecording = NO in its completion handler
+            [ScreenCaptureKitRecorder stopRecording];
 
-                g_usingStandaloneAudio = false;
-                MRSyncSetStopLimitSeconds(-1.0);
-                return Napi::Boolean::New(env, true);
-            }
-        } @catch (NSException *exception) {
-            NSLog(@"❌ Exception in ScreenCaptureKit stop: %@", exception.reason);
-            g_isRecording = false;
+            // DO NOT set g_isRecording here - let ScreenCaptureKit completion handler do it
+            // Otherwise we have a race condition where JS thinks recording stopped but it's still running
             g_usingStandaloneAudio = false;
-            return Napi::Boolean::New(env, false);
+            MRSyncSetStopLimitSeconds(-1.0);
+            return Napi::Boolean::New(env, true);
         }
     }
     
@@ -668,11 +672,26 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
 
             bool avFoundationStopped = stopAVFoundationRecording();
 
-            // ELECTRON SAFETY: Don't use dispatch_group_wait - it blocks main thread and causes crashes
-            // Instead, just fire async stop and continue
+            // SYNC FIX: Wait for both camera AND audio to finish (increased timeout to 5s)
             if (cameraWasRecording || audioWasRecording) {
-                MRLog(@"🔄 Camera/Audio stop operations dispatched asynchronously (Electron-safe mode)");
-                // Operations will complete in background - don't wait for them
+                dispatch_time_t waitTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC));
+                long waitResult = dispatch_group_wait(stopGroup, waitTime);
+                if (waitResult != 0) {
+                    MRLog(@"⚠️ SYNC: Camera/Audio stop did not finish within 5 seconds");
+                    if (cameraWasRecording && !cameraStopResult) {
+                        MRLog(@"   ⚠️ Camera stop timed out");
+                    }
+                    if (audioWasRecording && !audioStopResult) {
+                        MRLog(@"   ⚠️ Audio stop timed out");
+                    }
+                } else {
+                    if (cameraWasRecording) {
+                        MRLog(@"✅ SYNC: Camera stopped successfully");
+                    }
+                    if (audioWasRecording) {
+                        MRLog(@"✅ SYNC: Audio stopped successfully");
+                    }
+                }
             }
 
             g_isRecording = false;