node-mac-recorder 2.21.36 → 2.21.37

package/.claude/settings.local.json

@@ -4,7 +4,8 @@
       "Bash(cat:*)",
       "Bash(pkill:*)",
       "Bash(for f in test-output/*1761946670140.mov)",
-      "Bash(node test.js:*)"
+      "Bash(node test.js:*)",
+      "Bash(sw_vers:*)"
     ],
     "deny": [],
     "ask": []

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -282,18 +282,41 @@ 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);
-        dispatch_source_set_timer(g_avTimer, dispatch_time(DISPATCH_TIME_NOW, 0), interval, interval / 10);
-        
+        // 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);
+
         // Retain objects before passing to block to prevent deallocation
         AVAssetWriterInput *localVideoInput = g_avVideoInput;
         AVAssetWriterInputPixelBufferAdaptor *localPixelBufferAdaptor = g_avPixelBufferAdaptor;
@@ -448,12 +471,25 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                 }
             }
         });
-        
-        dispatch_resume(g_avTimer);
-        g_avIsRecording = true;
-        
-        MRLog(@"🎥 AVFoundation recording started: %dx%d @ %.0ffps", 
-              (int)recordingSize.width, (int)recordingSize.height, fps);
+
+        // 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;
+        }
         
         return true;
         
@@ -490,14 +526,8 @@ extern "C" bool stopAVFoundationRecording() {
             // Mark as not recording FIRST to stop timer callbacks
             g_avIsRecording = false;
             
-            // Cancel timer and wait a brief moment for completion
+            // Cancel timer immediately (Electron-safe)
             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");
         }
@@ -510,13 +540,16 @@ extern "C" bool stopAVFoundationRecording() {
         
         AVAssetWriter *writer = g_avWriter;
         if (writer && writer.status == AVAssetWriterStatusWriting) {
-            dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+            // ELECTRON SAFETY: Don't use dispatch_semaphore_wait - causes crashes in Electron
+            // Just call finishWriting async and let it complete in background
             [writer finishWritingWithCompletionHandler:^{
-                dispatch_semaphore_signal(semaphore);
+                if (writer.status == AVAssetWriterStatusCompleted) {
+                    MRLog(@"✅ AVFoundation writer finished successfully");
+                } else if (writer.error) {
+                    NSLog(@"⚠️ AVFoundation writer error: %@", writer.error);
+                }
             }];
-            // 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);
+            MRLog(@"🔄 AVFoundation writer finishing asynchronously (Electron-safe mode)");
         }
         
         // Cleanup

package/src/mac_recorder.mm

@@ -137,29 +137,22 @@ 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() {
-    // ScreenCaptureKit cleanup
-    if (@available(macOS 12.3, *)) {
-        if ([ScreenCaptureKitRecorder isRecording]) {
-            [ScreenCaptureKitRecorder stopRecording];
-        }
-    }
-    
-    // AVFoundation cleanup (supports both Node.js and Electron)
-    if (isAVFoundationRecording()) {
-        stopAVFoundationRecording();
-    }
+    // ELECTRON SAFETY: Don't call stop operations here - they're async and cause crashes
+    // Just reset state flags if they're stuck
 
-    if (isCameraRecording()) {
-        stopCameraRecording();
-    }
-    if (isStandaloneAudioRecording()) {
-        stopStandaloneAudioRecording();
+    @try {
+        // Only reset flags, don't actually stop anything
+        g_isRecording = false;
+        g_usingStandaloneAudio = false;
+        MRSyncConfigure(NO);
+
+        MRLog(@"🧹 State flags reset (safe mode - no actual stop operations)");
+    } @catch (NSException *exception) {
+        NSLog(@"⚠️ Exception during state reset: %@", exception.reason);
     }
-    g_usingStandaloneAudio = false;
-    
-    g_isRecording = false;
-    MRSyncConfigure(NO);
 }
 
 // NAPI Function: Start Recording
@@ -171,24 +164,16 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         return env.Null();
     }
     
-    // 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();
-
+    // ELECTRON SAFETY: Just check if recording is active, don't try to clean up
+    // Cleanup operations during start cause crashes in Electron
     if (g_isRecording) {
-        MRLog(@"⚠️ Still recording after cleanup - forcing stop");
+        MRLog(@"⚠️ Recording already in progress");
         return Napi::Boolean::New(env, false);
     }
 
-    // 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);
-        }
-    }
+    // 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
     g_usingStandaloneAudio = false;
     
     std::string outputPath = info[0].As<Napi::String>().Utf8Value();
@@ -377,16 +362,16 @@ 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(@"✅ ELECTRON-FIRST: Both ScreenCaptureKit and AVFoundation fully supported");
+            MRLog(@"🔧 FORCING AVFoundation for Electron stability (ScreenCaptureKit crashes in Electron)");
+            forceAVFoundation = YES;  // CRITICAL: ScreenCaptureKit is unstable in Electron
         }
 
-        // CRITICAL FIX: Use ScreenCaptureKit on macOS 15+ for best compatibility
-        // Both ScreenCaptureKit and AVFoundation work in Electron (Electron-first design)
-        // Only fallback to AVFoundation if ScreenCaptureKit is unavailable
-        BOOL forceAVFoundation = NO;  // Let system choose based on availability
-
         MRLog(@"🔧 FRAMEWORK SELECTION: Smart selection based on macOS version");
         MRLog(@"   Environment: %@", isElectron ? @"Electron" : @"Node.js");
         MRLog(@"   macOS: %ld.%ld.%ld", (long)osVersion.majorVersion, (long)osVersion.minorVersion, (long)osVersion.patchVersion);
@@ -605,30 +590,41 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     
     // Try ScreenCaptureKit first
     if (@available(macOS 12.3, *)) {
-        if ([ScreenCaptureKitRecorder isRecording]) {
-            MRLog(@"🛑 Stopping ScreenCaptureKit recording");
+        @try {
+            if ([ScreenCaptureKitRecorder isRecording]) {
+                MRLog(@"🛑 Stopping ScreenCaptureKit recording");
 
-            // 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");
+                // 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);
+                    }
                 }
-            }
 
-            // Now stop ScreenCaptureKit (asynchronous)
-            // WARNING: [ScreenCaptureKitRecorder stopRecording] is ASYNC!
-            // It will set g_isRecording = NO in its completion handler
-            [ScreenCaptureKitRecorder stopRecording];
+                // 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);
+                }
 
-            // 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;
+                MRSyncSetStopLimitSeconds(-1.0);
+                return Napi::Boolean::New(env, true);
+            }
+        } @catch (NSException *exception) {
+            NSLog(@"❌ Exception in ScreenCaptureKit stop: %@", exception.reason);
+            g_isRecording = false;
             g_usingStandaloneAudio = false;
-            MRSyncSetStopLimitSeconds(-1.0);
-            return Napi::Boolean::New(env, true);
+            return Napi::Boolean::New(env, false);
         }
     }
     
@@ -672,26 +668,11 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
 
             bool avFoundationStopped = stopAVFoundationRecording();
 
-            // SYNC FIX: Wait for both camera AND audio to finish (increased timeout to 5s)
+            // ELECTRON SAFETY: Don't use dispatch_group_wait - it blocks main thread and causes crashes
+            // Instead, just fire async stop and continue
             if (cameraWasRecording || audioWasRecording) {
-                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");
-                    }
-                }
+                MRLog(@"🔄 Camera/Audio stop operations dispatched asynchronously (Electron-safe mode)");
+                // Operations will complete in background - don't wait for them
             }
 
             g_isRecording = false;