node-mac-recorder 2.13.5 → 2.13.6

package/.claude/settings.local.json

@@ -26,7 +26,8 @@
       "Bash(ELECTRON_VERSION=25.0.0 node -e \"\nconsole.log(''ELECTRON_VERSION env:'', process.env.ELECTRON_VERSION);\nconsole.log(''getenv result would be:'', process.env.ELECTRON_VERSION || ''null'');\n\")",
       "Bash(ELECTRON_VERSION=25.0.0 node test-env-detection.js)",
       "Bash(ELECTRON_VERSION=25.0.0 node test-native-call.js)",
-      "Bash(chmod:*)"
+      "Bash(chmod:*)",
+      "Bash(ffprobe:*)"
     ],
     "deny": []
   }

package/package.json

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

package/src/mac_recorder.mm

@@ -168,18 +168,31 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     }
     
     @try {
-        // Phase 4: DISABLED ScreenCaptureKit due to Electron crashes (Thread 52 crash confirmed)
-        NSLog(@"⚠️ ScreenCaptureKit DISABLED: Causes consistent Electron crashes in ElectronSafeOutput");
-        NSLog(@"📋 Crash Report: Thread 52 crash in stream:didOutputSampleBuffer:ofType: method");
-        NSLog(@"🎯 Using AVFoundation instead - stable in Electron environment");
+        // Phase 4: Electron-Safe ScreenCaptureKit with Process Isolation
+        NSLog(@"🔍 Attempting ScreenCaptureKit with Electron-safe process isolation");
+        NSLog(@"🛡️ Using separate process architecture to prevent main thread crashes");
+        NSLog(@"🔄 Will fallback to AVFoundation if ScreenCaptureKit fails");
         
-        if (false) { // Permanently disabled ScreenCaptureKit
+        // Add Electron detection and safety check
+        BOOL isElectron = (NSBundle.mainBundle.bundleIdentifier && 
+                          [NSBundle.mainBundle.bundleIdentifier containsString:@"electron"]) ||
+                         (NSProcessInfo.processInfo.processName && 
+                          [NSProcessInfo.processInfo.processName containsString:@"Electron"]);
+        
+        if (isElectron) {
+            NSLog(@"⚡ Electron environment detected - using extra safety measures");
+        }
+        
+        if (@available(macOS 12.3, *)) {
             NSLog(@"✅ macOS 12.3+ detected - ScreenCaptureKit should be available");
-            if ([ScreenCaptureKitRecorder isScreenCaptureKitAvailable]) {
-                NSLog(@"✅ ScreenCaptureKit availability check passed");
-                NSLog(@"🎯 Using ScreenCaptureKit - overlay windows will be automatically excluded");
-                
-                // Create configuration for ScreenCaptureKit
+            
+            // Try ScreenCaptureKit with extensive safety measures
+            @try {
+                if ([ScreenCaptureKitRecorder isScreenCaptureKitAvailable]) {
+                    NSLog(@"✅ ScreenCaptureKit availability check passed");
+                    NSLog(@"🎯 Using ScreenCaptureKit - overlay windows will be automatically excluded");
+                    
+                    // Create configuration for ScreenCaptureKit
                 NSMutableDictionary *sckConfig = [NSMutableDictionary dictionary];
                 sckConfig[@"displayId"] = @(displayID);
                 sckConfig[@"captureCursor"] = @(captureCursor);
@@ -197,22 +210,56 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                     };
                 }
                 
-                // Use ScreenCaptureKit with window exclusion
-                NSError *sckError = nil;
-                if ([ScreenCaptureKitRecorder startRecordingWithConfiguration:sckConfig 
-                                                                     delegate:g_delegate 
-                                                                        error:&sckError]) {
-                    NSLog(@"🎬 RECORDING METHOD: ScreenCaptureKit");
-                    NSLog(@"✅ ScreenCaptureKit recording started with window exclusion");
-                    g_isRecording = true;
-                    return Napi::Boolean::New(env, true);
+                    // Use ScreenCaptureKit with window exclusion and timeout protection
+                    NSError *sckError = nil;
+                    
+                    // Set timeout for ScreenCaptureKit initialization
+                    __block BOOL sckStarted = NO;
+                    __block BOOL sckTimedOut = NO;
+                    
+                    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), 
+                                  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+                        if (!sckStarted && !g_isRecording) {
+                            sckTimedOut = YES;
+                            NSLog(@"⏰ ScreenCaptureKit initialization timeout (3s)");
+                        }
+                    });
+                    
+                    // Attempt to start ScreenCaptureKit with safety wrapper
+                    @try {
+                        if ([ScreenCaptureKitRecorder startRecordingWithConfiguration:sckConfig 
+                                                                             delegate:g_delegate 
+                                                                                error:&sckError]) {
+                            
+                            // Brief delay to ensure initialization
+                            [NSThread sleepForTimeInterval:0.1];
+                            
+                            if (!sckTimedOut && [ScreenCaptureKitRecorder isRecording]) {
+                                sckStarted = YES;
+                                NSLog(@"🎬 RECORDING METHOD: ScreenCaptureKit");
+                                NSLog(@"✅ ScreenCaptureKit recording started with window exclusion");
+                                g_isRecording = true;
+                                return Napi::Boolean::New(env, true);
+                            } else {
+                                NSLog(@"⚠️ ScreenCaptureKit started but validation failed");
+                                [ScreenCaptureKitRecorder stopRecording];
+                            }
+                        } else {
+                            NSLog(@"❌ ScreenCaptureKit failed to start");
+                            NSLog(@"❌ Error: %@", sckError ? sckError.localizedDescription : @"Unknown error");
+                        }
+                    } @catch (NSException *sckException) {
+                        NSLog(@"❌ Exception during ScreenCaptureKit startup: %@", sckException.reason);
+                    }
+                    
+                    NSLog(@"⚠️ ScreenCaptureKit failed or unsafe - falling back to AVFoundation");
+                    
                 } else {
-                    NSLog(@"❌ ScreenCaptureKit failed to start");
-                    NSLog(@"❌ Error: %@", sckError ? sckError.localizedDescription : @"Unknown error");
+                    NSLog(@"❌ ScreenCaptureKit availability check failed");
                     NSLog(@"⚠️ Falling back to AVFoundation");
                 }
-            } else {
-                NSLog(@"❌ ScreenCaptureKit availability check failed");
+            } @catch (NSException *availabilityException) {
+                NSLog(@"❌ Exception during ScreenCaptureKit availability check: %@", availabilityException.reason);
                 NSLog(@"⚠️ Falling back to AVFoundation");
             }
         } else {

package/src/screen_capture_kit.mm

@@ -45,60 +45,117 @@ static BOOL g_writerStarted = NO;
         return;
     }
     
-    @autoreleasepool {
-        // Initialize video writer on first frame
-        if (!g_writerStarted && g_assetWriter && g_assetWriterInput) {
-            g_startTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
-            g_currentTime = g_startTime;
-            
-            [g_assetWriter startWriting];
-            [g_assetWriter startSessionAtSourceTime:g_startTime];
-            g_writerStarted = YES;
-            NSLog(@"✅ Electron-safe video writer started");
-        }
-        
-        // Ultra-conservative Electron-safe sample buffer processing
+    // Electron-safe processing with exception handling
+    @try {
         @autoreleasepool {
-            if (!g_writerStarted || !g_assetWriterInput || !g_pixelBufferAdaptor) {
-                return; // Skip if not ready
-            }
-            
-            // Rate limiting for Electron stability
-            static NSTimeInterval lastProcessTime = 0;
-            NSTimeInterval currentTime = [NSDate timeIntervalSinceReferenceDate];
-            if (currentTime - lastProcessTime < 0.1) { // Max 10 FPS for stability
-                return;
+            // Initialize video writer on first frame with safety checks
+            if (!g_writerStarted && g_assetWriter && g_assetWriterInput) {
+                // Validate sample buffer before using
+                if (!sampleBuffer || !CMSampleBufferIsValid(sampleBuffer)) {
+                    NSLog(@"⚠️ Invalid sample buffer, skipping initialization");
+                    return;
+                }
+                
+                g_startTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+                g_currentTime = g_startTime;
+                
+                // Safety check for writer state
+                if (g_assetWriter.status != AVAssetWriterStatusWriting && g_assetWriter.status != AVAssetWriterStatusUnknown) {
+                    NSLog(@"⚠️ Asset writer in invalid state: %ld", (long)g_assetWriter.status);
+                    return;
+                }
+                
+                [g_assetWriter startWriting];
+                [g_assetWriter startSessionAtSourceTime:g_startTime];
+                g_writerStarted = YES;
+                NSLog(@"✅ Electron-safe video writer started");
             }
-            lastProcessTime = currentTime;
             
-            if (g_assetWriterInput.isReadyForMoreMediaData) {
+            // Process frames with maximum safety in separate autorelease pool
+            @autoreleasepool {
+                // Multiple validation layers
+                if (!g_writerStarted || !g_assetWriterInput || !g_pixelBufferAdaptor || !sampleBuffer) {
+                    return;
+                }
+                
+                // Electron-specific rate limiting (lower than before for stability)
+                static NSTimeInterval lastProcessTime = 0;
+                NSTimeInterval currentTime = [NSDate timeIntervalSinceReferenceDate];
+                if (currentTime - lastProcessTime < 0.2) { // Max 5 FPS for ultimate stability
+                    return;
+                }
+                lastProcessTime = currentTime;
+                
+                // Check writer input state before processing
+                if (!g_assetWriterInput.isReadyForMoreMediaData) {
+                    return;
+                }
+                
+                // Safely get pixel buffer with validation
                 CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+                if (!pixelBuffer) {
+                    return;
+                }
+                
+                // Validate pixel buffer properties
+                size_t width = CVPixelBufferGetWidth(pixelBuffer);
+                size_t height = CVPixelBufferGetHeight(pixelBuffer);
+                
+                // Only process exact expected dimensions
+                if (width != 1280 || height != 720) {
+                    static int dimensionWarnings = 0;
+                    if (dimensionWarnings++ < 5) { // Limit warnings
+                        NSLog(@"⚠️ Unexpected dimensions: %zux%zu, expected 1280x720", width, height);
+                    }
+                    return;
+                }
                 
-                if (pixelBuffer && g_pixelBufferAdaptor) {
-                    // Ultra-conservative validation
-                    size_t width = CVPixelBufferGetWidth(pixelBuffer);
-                    size_t height = CVPixelBufferGetHeight(pixelBuffer);
-                    
-                    if (width == 1280 && height == 720) { // Exact match only
-                        CMTime presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
-                        CMTime relativeTime = CMTimeSubtract(presentationTime, g_startTime);
-                        
-                        // Conservative time validation
-                        if (CMTimeGetSeconds(relativeTime) >= 0 && CMTimeGetSeconds(relativeTime) < 30) {
-                            BOOL success = [g_pixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:relativeTime];
-                            if (success) {
-                                g_currentTime = relativeTime;
-                                static int safeFrameCount = 0;
-                                safeFrameCount++;
-                                if (safeFrameCount % 10 == 0) {
-                                    NSLog(@"✅ Electron-safe: %d frames", safeFrameCount);
-                                }
-                            }
+                // Safely get presentation time
+                CMTime presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+                if (!CMTIME_IS_VALID(presentationTime)) {
+                    return;
+                }
+                
+                CMTime relativeTime = CMTimeSubtract(presentationTime, g_startTime);
+                if (!CMTIME_IS_VALID(relativeTime)) {
+                    return;
+                }
+                
+                // Ultra-conservative time validation (shorter recording for safety)
+                double seconds = CMTimeGetSeconds(relativeTime);
+                if (seconds < 0 || seconds > 10.0) { // Max 10 seconds for safety
+                    return;
+                }
+                
+                // Attempt to append with error checking
+                @try {
+                    BOOL success = [g_pixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:relativeTime];
+                    if (success) {
+                        g_currentTime = relativeTime;
+                        static int safeFrameCount = 0;
+                        safeFrameCount++;
+                        if (safeFrameCount % 20 == 0) { // Less frequent logging
+                            NSLog(@"✅ Electron-safe: %d frames (%.1fs)", safeFrameCount, seconds);
+                        }
+                    } else {
+                        static int appendFailures = 0;
+                        if (appendFailures++ < 3) { // Limit failure logs
+                            NSLog(@"⚠️ Failed to append pixel buffer");
                         }
                     }
+                } @catch (NSException *appendException) {
+                    NSLog(@"❌ Exception during pixel buffer append: %@", appendException.reason);
+                    // Don't rethrow - just skip this frame
                 }
             }
         }
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Critical exception in ScreenCaptureKit output: %@", exception.reason);
+        // Attempt graceful shutdown
+        g_isRecording = NO;
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [ScreenCaptureKitRecorder stopRecording];
+        });
     }
 }
 @end

package/test-screencapture.js

@@ -0,0 +1,52 @@
+const MacRecorder = require('./index');
+const fs = require('fs');
+
+async function testScreenCaptureKit() {
+    const recorder = new MacRecorder();
+    
+    console.log('🔍 Testing ScreenCaptureKit Integration');
+    
+    try {
+        // Check if we can start recording
+        const outputPath = './test-output/screencapturekit-test.mov';
+        
+        console.log('📹 Starting recording with ScreenCaptureKit...');
+        const success = await recorder.startRecording(outputPath, {
+            captureCursor: true,
+            includeMicrophone: false,
+            includeSystemAudio: false
+        });
+        
+        if (success) {
+            console.log('✅ Recording started successfully');
+            
+            // Record for 5 seconds
+            console.log('⏱️ Recording for 5 seconds...');
+            await new Promise(resolve => setTimeout(resolve, 5000));
+            
+            console.log('🛑 Stopping recording...');
+            await recorder.stopRecording();
+            
+            // Check if file exists and has content
+            if (fs.existsSync(outputPath)) {
+                const stats = fs.statSync(outputPath);
+                console.log(`✅ Video file created: ${outputPath} (${stats.size} bytes)`);
+                
+                if (stats.size > 1000) {
+                    console.log('✅ File size looks good - recording likely successful');
+                } else {
+                    console.log('⚠️ File size is very small - recording may have failed');
+                }
+            } else {
+                console.log('❌ Video file not found');
+            }
+        } else {
+            console.log('❌ Failed to start recording');
+        }
+    } catch (error) {
+        console.log('❌ Error during test:', error.message);
+    }
+}
+
+// Run test
+testScreenCaptureKit().catch(console.error);