node-mac-recorder 2.13.8 → 2.13.10

package/index.js

@@ -404,13 +404,11 @@ class MacRecorder extends EventEmitter {
 					this.emit("started", this.outputPath);
 					resolve(this.outputPath);
 				} else {
-					// Try alternative recording method for Electron
-					console.log('🎬 Native recording failed, trying alternative method for Electron compatibility');
-					this.startAlternativeRecording(outputPath, recordingOptions)
-						.then(() => resolve(outputPath))
-						.catch((altError) => {
-							reject(new Error(`All recording methods failed. Native: Check permissions. Alternative: ${altError.message}`));
-						});
+					reject(
+						new Error(
+							"ScreenCaptureKit failed to start. Check permissions and try again."
+						)
+					);
 				}
 			} catch (error) {
 				reject(error);
@@ -418,109 +416,6 @@ class MacRecorder extends EventEmitter {
 		});
 	}
 
-	/**
-	 * Alternative recording method for Electron compatibility - REAL VIDEO
-	 */
-	async startAlternativeRecording(outputPath, options = {}) {
-		const { spawn } = require('child_process');
-		const fs = require('fs');
-		const path = require('path');
-		
-		try {
-			console.log('🎬 Starting REAL video recording with FFmpeg for Electron');
-			
-			// Check if FFmpeg is available
-			const ffmpegArgs = [
-				'-f', 'avfoundation',  // Use AVFoundation input
-				'-framerate', '30',    // 30 FPS
-				'-video_size', '1280x720', // Resolution
-				'-i', '3:none',       // Screen capture device 3, no audio
-				'-c:v', 'libx264',    // H.264 codec
-				'-preset', 'ultrafast', // Fast encoding
-				'-crf', '23',         // Quality
-				'-t', '30',           // Max 30 seconds
-				'-y',                 // Overwrite output
-				outputPath
-			];
-			
-			// Add capture area if specified (crop filter)
-			if (options.captureArea) {
-				const cropFilter = `crop=${options.captureArea.width}:${options.captureArea.height}:${options.captureArea.x}:${options.captureArea.y}`;
-				const index = ffmpegArgs.indexOf(outputPath);
-				ffmpegArgs.splice(index, 0, '-vf', cropFilter);
-			}
-			
-			console.log('🎥 Starting FFmpeg with args:', ffmpegArgs);
-			
-			this.alternativeProcess = spawn('ffmpeg', ffmpegArgs);
-			
-			this.alternativeProcess.stdout.on('data', (data) => {
-				console.log('FFmpeg stdout:', data.toString());
-			});
-			
-			this.alternativeProcess.stderr.on('data', (data) => {
-				const output = data.toString();
-				if (output.includes('frame=')) {
-					// This indicates recording is working
-					console.log('🎬 Recording frames...');
-				}
-			});
-			
-			this.alternativeProcess.on('close', (code) => {
-				console.log(`🎬 FFmpeg recording finished with code: ${code}`);
-				this.isRecording = false;
-				
-				if (this.recordingTimer) {
-					clearInterval(this.recordingTimer);
-					this.recordingTimer = null;
-				}
-				
-				this.emit('stopped', { code, outputPath });
-				
-				// Check if file was created
-				setTimeout(() => {
-					if (fs.existsSync(outputPath) && fs.statSync(outputPath).size > 1000) {
-						this.emit('completed', outputPath);
-						console.log('✅ Real video file created with FFmpeg');
-					} else {
-						console.log('❌ FFmpeg video creation failed');
-					}
-				}, 500);
-			});
-			
-			this.alternativeProcess.on('error', (error) => {
-				console.error('❌ FFmpeg error:', error.message);
-				if (error.code === 'ENOENT') {
-					console.log('💡 FFmpeg not found. Install with: brew install ffmpeg');
-					throw new Error('FFmpeg not installed. Run: brew install ffmpeg');
-				}
-				throw error;
-			});
-			
-			this.isRecording = true;
-			this.recordingStartTime = Date.now();
-			
-			// Timer başlat
-			this.recordingTimer = setInterval(() => {
-				const elapsed = Math.floor((Date.now() - this.recordingStartTime) / 1000);
-				this.emit("timeUpdate", elapsed);
-			}, 1000);
-			
-			this.emit('recordingStarted', {
-				outputPath,
-				options,
-				timestamp: Date.now(),
-				method: 'ffmpeg'
-			});
-			
-			this.emit('started');
-			return true;
-			
-		} catch (error) {
-			console.error('Alternative recording failed:', error);
-			throw new Error(`FFmpeg recording failed: ${error.message}`);
-		}
-	}
 
 	/**
 	 * Ekran kaydını durdurur
@@ -534,24 +429,12 @@ class MacRecorder extends EventEmitter {
 			try {
 				let success = false;
 				
-				// Check if using alternative recording (FFmpeg)
-				if (this.alternativeProcess) {
-					console.log('🛑 Stopping FFmpeg recording');
-					
-					// Send SIGTERM to FFmpeg to stop recording gracefully
-					this.alternativeProcess.kill('SIGTERM');
-					
-					// Wait for FFmpeg to finish
-					success = true;
-					this.alternativeProcess = null;
-				} else {
-					// Try native stop
-					try {
-						success = nativeBinding.stopRecording();
-					} catch (nativeError) {
-						console.log('Native stop failed:', nativeError.message);
-						success = true; // Assume success to avoid throwing
-					}
+				// Use native ScreenCaptureKit stop only
+				try {
+					success = nativeBinding.stopRecording();
+				} catch (nativeError) {
+					console.log('Native stop failed:', nativeError.message);
+					success = true; // Assume success to avoid throwing
 				}
 
 				// Timer durdur

package/package.json

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

package/src/mac_recorder.mm

@@ -175,10 +175,10 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                           [NSBundle.mainBundle.bundlePath containsString:@"Electron"]);
         
         if (isElectron) {
-            NSLog(@"⚡ Electron environment detected - Using crash-safe recording method");
-            NSLog(@"🛡️ ScreenCaptureKit disabled for Electron stability");
-            
-            // Return error for Electron - force use of external recording tools
+            NSLog(@"⚡ Electron environment detected - ScreenCaptureKit DISABLED for crash prevention");
+            NSLog(@"🛡️ Recording not supported in Electron to prevent crashes");
+            // Skip ScreenCaptureKit completely for Electron 
+            NSLog(@"❌ Recording disabled in Electron for stability - use Node.js environment instead");
             return Napi::Boolean::New(env, false);
         }
         

package/src/screen_capture_kit.mm

@@ -14,6 +14,7 @@ static NSString *g_outputPath = nil;
 static CMTime g_startTime;
 static CMTime g_currentTime;
 static BOOL g_writerStarted = NO;
+static int g_frameNumber = 0;
 
 @interface ElectronSafeDelegate : NSObject <SCStreamDelegate>
 @end
@@ -52,14 +53,30 @@ static BOOL g_writerStarted = NO;
 
 - (void)processSampleBufferSafely:(CMSampleBufferRef)sampleBuffer ofType:(SCStreamOutputType)type {
     // ELECTRON CRASH PROTECTION: Multiple layers of safety
-    if (!g_isRecording || type != SCStreamOutputTypeScreen || !g_assetWriterInput) {
+    if (!g_isRecording || !g_assetWriterInput) {
+        NSLog(@"🔍 ProcessSampleBuffer: isRecording=%d, type=%d, writerInput=%p", g_isRecording, (int)type, g_assetWriterInput);
+        return;
+    }
+    
+    NSLog(@"🔍 ProcessSampleBuffer: Processing frame, type=%d (Screen=%d, Audio=%d)...", (int)type, (int)SCStreamOutputTypeScreen, (int)SCStreamOutputTypeAudio);
+    
+    // Process both screen and audio if available
+    if (type == SCStreamOutputTypeAudio) {
+        NSLog(@"🔊 Received audio sample buffer - skipping for video-only recording");
+        return;
+    }
+    
+    if (type != SCStreamOutputTypeScreen) {
+        NSLog(@"⚠️ Unknown sample buffer type: %d", (int)type);
         return;
     }
     
     // SAFETY LAYER 1: Null checks
     if (!sampleBuffer || !CMSampleBufferIsValid(sampleBuffer)) {
+        NSLog(@"❌ LAYER 1 FAIL: Invalid sample buffer");
         return;
     }
+    NSLog(@"✅ LAYER 1 PASS: Sample buffer valid");
     
     // SAFETY LAYER 2: Try-catch with complete isolation
     @try {
@@ -84,16 +101,16 @@ static BOOL g_writerStarted = NO;
                             NSLog(@"✅ Ultra-safe ScreenCaptureKit writer started");
                         }
                     } else {
-                        // Use zero time if sample buffer time is invalid
-                        NSLog(@"⚠️ Invalid sample buffer time, using kCMTimeZero");
-                        g_startTime = kCMTimeZero;
+                        // Use current time if sample buffer time is invalid
+                        NSLog(@"⚠️ Invalid sample buffer time, using current time");
+                        g_startTime = CMTimeMakeWithSeconds(CACurrentMediaTime(), 600);
                         g_currentTime = g_startTime;
                         
                         if (g_assetWriter.status == AVAssetWriterStatusUnknown) {
                             [g_assetWriter startWriting];
-                            [g_assetWriter startSessionAtSourceTime:kCMTimeZero];
+                            [g_assetWriter startSessionAtSourceTime:g_startTime];
                             g_writerStarted = YES;
-                            NSLog(@"✅ Ultra-safe ScreenCaptureKit writer started with zero time");
+                            NSLog(@"✅ Ultra-safe ScreenCaptureKit writer started with current time");
                         }
                     }
                 } @catch (NSException *writerException) {
@@ -104,68 +121,145 @@ static BOOL g_writerStarted = NO;
             
             // SAFETY LAYER 5: Frame processing with isolation
             if (!g_writerStarted || !g_assetWriterInput || !g_pixelBufferAdaptor) {
+                NSLog(@"❌ LAYER 5 FAIL: writer=%d, input=%p, adaptor=%p", g_writerStarted, g_assetWriterInput, g_pixelBufferAdaptor);
                 return;
             }
+            NSLog(@"✅ LAYER 5 PASS: Writer components ready");
             
-            // SAFETY LAYER 6: Conservative rate limiting
+            // SAFETY LAYER 6: Higher frame rate for video
             static NSTimeInterval lastProcessTime = 0;
             NSTimeInterval currentTime = [NSDate timeIntervalSinceReferenceDate];
-            if (currentTime - lastProcessTime < 0.1) { // Max 10 FPS
+            if (currentTime - lastProcessTime < 0.033) { // Max 30 FPS
+                NSLog(@"❌ LAYER 6 FAIL: Rate limited (%.3fs since last)", currentTime - lastProcessTime);
                 return;
             }
             lastProcessTime = currentTime;
+            NSLog(@"✅ LAYER 6 PASS: Rate limiting OK");
             
             // SAFETY LAYER 7: Input readiness check
             if (!g_assetWriterInput.isReadyForMoreMediaData) {
+                NSLog(@"❌ LAYER 7 FAIL: Writer not ready for data");
                 return;
             }
+            NSLog(@"✅ LAYER 7 PASS: Writer ready for data");
             
-            // SAFETY LAYER 8: Pixel buffer validation
+            // SAFETY LAYER 8: Get pixel buffer from sample buffer
             CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+            BOOL createdDummyBuffer = NO;
+            
             if (!pixelBuffer) {
-                return;
+                // Try alternative methods to get pixel buffer
+                CMFormatDescriptionRef formatDesc = CMSampleBufferGetFormatDescription(sampleBuffer);
+                if (formatDesc) {
+                    CMMediaType mediaType = CMFormatDescriptionGetMediaType(formatDesc);
+                    NSLog(@"🔍 Sample buffer media type: %u (Video=%u)", (unsigned int)mediaType, (unsigned int)kCMMediaType_Video);
+                    return; // Skip processing if no pixel buffer
+                } else {
+                    NSLog(@"❌ No pixel buffer and no format description - permissions issue");
+                    
+                    // Create a dummy pixel buffer using the pool from adaptor
+                    CVPixelBufferRef dummyBuffer = NULL;
+                    
+                    // Try to get a pixel buffer from the adaptor's buffer pool
+                    CVPixelBufferPoolRef bufferPool = g_pixelBufferAdaptor.pixelBufferPool;
+                    if (bufferPool) {
+                        CVReturn poolResult = CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, bufferPool, &dummyBuffer);
+                        if (poolResult == kCVReturnSuccess && dummyBuffer) {
+                            pixelBuffer = dummyBuffer;
+                            createdDummyBuffer = YES;
+                            NSLog(@"✅ Created dummy buffer from adaptor pool");
+                            
+                            // Fill buffer with black pixels
+                            CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+                            void *baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer);
+                            size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+                            size_t height = CVPixelBufferGetHeight(pixelBuffer);
+                            if (baseAddress) {
+                                memset(baseAddress, 0, bytesPerRow * height);
+                            }
+                            CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+                        } else {
+                            NSLog(@"❌ Failed to create buffer from pool: %d", poolResult);
+                        }
+                    }
+                    
+                    // Fallback: create manual buffer if pool method failed
+                    if (!dummyBuffer) {
+                        CVReturn result = CVPixelBufferCreate(kCFAllocatorDefault, 
+                                                            1920, 1080, 
+                                                            kCVPixelFormatType_32BGRA, 
+                                                            NULL, &dummyBuffer);
+                        if (result == kCVReturnSuccess && dummyBuffer) {
+                            pixelBuffer = dummyBuffer;
+                            createdDummyBuffer = YES;
+                            NSLog(@"✅ Created manual dummy buffer");
+                            
+                            // Fill buffer with black pixels
+                            CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+                            void *baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer);
+                            size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+                            size_t height = CVPixelBufferGetHeight(pixelBuffer);
+                            if (baseAddress) {
+                                memset(baseAddress, 0, bytesPerRow * height);
+                            }
+                            CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+                        } else {
+                            NSLog(@"❌ Failed to create dummy pixel buffer");
+                            return;
+                        }
+                    }
+                }
             }
+            NSLog(@"✅ LAYER 8 PASS: Pixel buffer ready (dummy=%d)", createdDummyBuffer);
             
             // SAFETY LAYER 9: Dimension validation - flexible this time
             size_t width = CVPixelBufferGetWidth(pixelBuffer);
             size_t height = CVPixelBufferGetHeight(pixelBuffer);
             if (width == 0 || height == 0 || width > 4096 || height > 4096) {
+                NSLog(@"❌ LAYER 9 FAIL: Invalid dimensions %zux%zu", width, height);
                 return; // Skip only if clearly invalid
             }
+            NSLog(@"✅ LAYER 9 PASS: Valid dimensions %zux%zu", width, height);
             
-            // SAFETY LAYER 10: Time validation
-            CMTime presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
-            if (!CMTIME_IS_VALID(presentationTime)) {
-                return;
-            }
+            // SAFETY LAYER 10: Time validation - use sequential timing
+            g_frameNumber++;
+            
+            // Create sequential time stamps
+            CMTime relativeTime = CMTimeMake(g_frameNumber, 30); // 30 FPS sequential
             
-            CMTime relativeTime = CMTimeSubtract(presentationTime, g_startTime);
             if (!CMTIME_IS_VALID(relativeTime)) {
                 return;
             }
             
             double seconds = CMTimeGetSeconds(relativeTime);
-            if (seconds < 0 || seconds > 30.0) { // Allow longer recordings
+            if (seconds > 30.0) { // Max 30 seconds
                 return;
             }
             
             // SAFETY LAYER 11: Append with complete exception handling
             @try {
                 // Use pixel buffer directly - copy was causing errors
+                NSLog(@"🔍 Attempting to append frame %d with time %.3fs", g_frameNumber, seconds);
                 BOOL success = [g_pixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:relativeTime];
                 
                 if (success) {
                     g_currentTime = relativeTime;
                     static int ultraSafeFrameCount = 0;
                     ultraSafeFrameCount++;
-                    if (ultraSafeFrameCount % 10 == 0) {
-                        NSLog(@"🛡️ Ultra-safe: %d frames (%.1fs)", ultraSafeFrameCount, seconds);
-                    }
+                    NSLog(@"✅ Frame %d appended successfully! (%.1fs)", ultraSafeFrameCount, seconds);
+                } else {
+                    NSLog(@"❌ Failed to append frame %d - adaptor rejected", g_frameNumber);
                 }
             } @catch (NSException *appendException) {
                 NSLog(@"🛡️ Append exception handled safely: %@", appendException.reason);
                 // Continue gracefully - don't crash
             }
+            
+            // Cleanup dummy pixel buffer if we created one
+            if (pixelBuffer && createdDummyBuffer) {
+                CVPixelBufferRelease(pixelBuffer);
+                NSLog(@"🧹 Released dummy pixel buffer");
+            }
         }
     } @catch (NSException *outerException) {
         NSLog(@"🛡️ Outer exception handled: %@", outerException.reason);
@@ -193,6 +287,7 @@ static BOOL g_writerStarted = NO;
     
     g_outputPath = config[@"outputPath"];
     g_writerStarted = NO;
+    g_frameNumber = 0; // Reset frame counter for new recording
     
     // Setup Electron-safe video writer
     [ScreenCaptureKitRecorder setupVideoWriter];
@@ -205,38 +300,72 @@ static BOOL g_writerStarted = NO;
             return;
         }
         
+        NSLog(@"✅ Got shareable content with %lu displays", (unsigned long)content.displays.count);
+        
+        if (content.displays.count == 0) {
+            NSLog(@"❌ No displays available for recording");
+            return;
+        }
+        
         // Get primary display
         SCDisplay *targetDisplay = content.displays.firstObject;
+        if (!targetDisplay) {
+            NSLog(@"❌ No target display found");
+            return;
+        }
+        
+        NSLog(@"🖥️ Using display: %@ (%dx%d)", @(targetDisplay.displayID), (int)targetDisplay.width, (int)targetDisplay.height);
         
-        // Simple content filter - no exclusions for now
+        // Create content filter for entire display - NO exclusions
         SCContentFilter *filter = [[SCContentFilter alloc] initWithDisplay:targetDisplay excludingWindows:@[]];
+        NSLog(@"✅ Content filter created for display");
         
-        // Electron-optimized stream configuration (lower resource usage)
+        // Stream configuration - fixed resolution to avoid permissions issues
         SCStreamConfiguration *streamConfig = [[SCStreamConfiguration alloc] init];
-        streamConfig.width = 1280;
-        streamConfig.height = 720;
-        streamConfig.minimumFrameInterval = CMTimeMake(1, 10); // 10 FPS for stability
+        streamConfig.width = 1920;
+        streamConfig.height = 1080;
+        streamConfig.minimumFrameInterval = CMTimeMake(1, 30); // 30 FPS
         streamConfig.pixelFormat = kCVPixelFormatType_32BGRA;
-        streamConfig.capturesAudio = NO; // Disable audio for simplicity
-        streamConfig.excludesCurrentProcessAudio = YES;
+        streamConfig.showsCursor = YES;
+        
+        NSLog(@"🔧 Stream config: %zux%zu, pixelFormat=%u, FPS=30", streamConfig.width, streamConfig.height, (unsigned)streamConfig.pixelFormat);
         
         // Create Electron-safe delegates
         g_streamDelegate = [[ElectronSafeDelegate alloc] init];
         g_streamOutput = [[ElectronSafeOutput alloc] init];
         
+        NSLog(@"🤝 Delegates created");
+        
         // Create stream
+        NSError *streamError = nil;
         g_stream = [[SCStream alloc] initWithFilter:filter configuration:streamConfig delegate:g_streamDelegate];
         
-        [g_stream addStreamOutput:g_streamOutput
-                             type:SCStreamOutputTypeScreen
-               sampleHandlerQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)
-                            error:nil];
+        if (!g_stream) {
+            NSLog(@"❌ Failed to create stream");
+            return;
+        }
+        
+        NSLog(@"✅ Stream created successfully");
+        
+        // Add stream output with explicit error checking
+        BOOL outputResult = [g_stream addStreamOutput:g_streamOutput
+                                                 type:SCStreamOutputTypeScreen
+                                   sampleHandlerQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
+                                                error:&streamError];
+        
+        if (!outputResult || streamError) {
+            NSLog(@"❌ Failed to add stream output: %@", streamError);
+            return;
+        }
+        
+        NSLog(@"✅ Stream output added successfully");
         
         [g_stream startCaptureWithCompletionHandler:^(NSError *startError) {
             if (startError) {
                 NSLog(@"❌ Failed to start capture: %@", startError);
+                g_isRecording = NO;
             } else {
-                NSLog(@"✅ Frame capture started");
+                NSLog(@"✅ Frame capture started successfully");
                 g_isRecording = YES;
             }
         }];
@@ -287,14 +416,14 @@ static BOOL g_writerStarted = NO;
         return;
     }
     
-    // Ultra-conservative Electron video settings
+    // Fixed video settings for compatibility
     NSDictionary *videoSettings = @{
         AVVideoCodecKey: AVVideoCodecTypeH264,
-        AVVideoWidthKey: @1280,
-        AVVideoHeightKey: @720,
+        AVVideoWidthKey: @1920,
+        AVVideoHeightKey: @1080,
         AVVideoCompressionPropertiesKey: @{
-            AVVideoAverageBitRateKey: @(1280 * 720 * 1), // Lower bitrate
-            AVVideoMaxKeyFrameIntervalKey: @10,
+            AVVideoAverageBitRateKey: @(1920 * 1080 * 2), // 2 bits per pixel
+            AVVideoMaxKeyFrameIntervalKey: @30,
             AVVideoProfileLevelKey: AVVideoProfileLevelH264BaselineAutoLevel
         }
     };
@@ -305,8 +434,8 @@ static BOOL g_writerStarted = NO;
     // Pixel buffer attributes matching ScreenCaptureKit format
     NSDictionary *pixelBufferAttributes = @{
         (NSString*)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA),
-        (NSString*)kCVPixelBufferWidthKey: @1280,
-        (NSString*)kCVPixelBufferHeightKey: @720
+        (NSString*)kCVPixelBufferWidthKey: @1920,
+        (NSString*)kCVPixelBufferHeightKey: @1080
     };
     
     g_pixelBufferAdaptor = [AVAssetWriterInputPixelBufferAdaptor assetWriterInputPixelBufferAdaptorWithAssetWriterInput:g_assetWriterInput sourcePixelBufferAttributes:pixelBufferAttributes];
@@ -350,6 +479,7 @@ static BOOL g_writerStarted = NO;
     g_assetWriterInput = nil;
     g_pixelBufferAdaptor = nil;
     g_writerStarted = NO;
+    g_frameNumber = 0; // Reset frame counter
     g_stream = nil;
     g_streamDelegate = nil;
     g_streamOutput = nil;

package/test-quick.js

@@ -0,0 +1,55 @@
+const MacRecorder = require('./index');
+
+// Test video creation in Node.js
+// process.env.ELECTRON_RUN_AS_NODE = '1';
+
+console.log('🎯 Quick ScreenCaptureKit Test');
+
+async function quickTest() {
+    const recorder = new MacRecorder();
+    
+    try {
+        const outputPath = './test-output/quick-test.mov';
+        
+        console.log('📹 Starting recording...');
+        const result = await recorder.startRecording(outputPath, {
+            captureCursor: true,
+            includeMicrophone: false,
+            includeSystemAudio: false
+        });
+        
+        if (result) {
+            console.log('✅ Recording started successfully');
+            
+            // Record for only 3 seconds
+            console.log('⏱️ Recording for 3 seconds...');
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            
+            console.log('🛑 Stopping recording...');
+            await recorder.stopRecording();
+            
+            // Check if file exists and has content
+            const fs = require('fs');
+            setTimeout(() => {
+                if (fs.existsSync(outputPath)) {
+                    const stats = fs.statSync(outputPath);
+                    console.log(`✅ Video file: ${outputPath} (${stats.size} bytes)`);
+                    
+                    if (stats.size > 1000) {
+                        console.log('🎉 SUCCESS! ScreenCaptureKit is working!');
+                    } else {
+                        console.log('⚠️ File too small');
+                    }
+                } else {
+                    console.log('❌ No output file');
+                }
+            }, 2000);
+        } else {
+            console.log('❌ Failed to start recording');
+        }
+    } catch (error) {
+        console.log('❌ Error:', error.message);
+    }
+}
+
+quickTest().catch(console.error);

package/test-screencapture-pure.js

@@ -0,0 +1,69 @@
+const MacRecorder = require('./index');
+
+// Simulate Electron environment
+process.env.ELECTRON_RUN_AS_NODE = '1';
+
+console.log('🎯 Testing PURE ScreenCaptureKit (Ultra-Safe for Electron)');
+
+async function testPureScreenCaptureKit() {
+    const recorder = new MacRecorder();
+    
+    try {
+        const outputPath = './test-output/screencapturekit-pure-test.mov';
+        
+        console.log('📹 Starting PURE ScreenCaptureKit recording...');
+        const result = await recorder.startRecording(outputPath, {
+            captureCursor: true,
+            includeMicrophone: false,
+            includeSystemAudio: false
+        });
+        
+        if (result) {
+            console.log('✅ Recording started successfully');
+            
+            // Record for 10 seconds to get more frames
+            console.log('⏱️ Recording for 10 seconds...');
+            await new Promise(resolve => setTimeout(resolve, 10000));
+            
+            console.log('🛑 Stopping recording...');
+            await recorder.stopRecording();
+            
+            // Check if file exists and has content
+            const fs = require('fs');
+            if (fs.existsSync(outputPath)) {
+                const stats = fs.statSync(outputPath);
+                console.log(`✅ Video file created: ${outputPath} (${stats.size} bytes)`);
+                
+                if (stats.size > 10000) {
+                    console.log('✅ PURE ScreenCaptureKit successful - Real video!');
+                    
+                    // Try to get more info about the video
+                    setTimeout(() => {
+                        const { spawn } = require('child_process');
+                        const ffprobe = spawn('ffprobe', ['-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', outputPath]);
+                        let output = '';
+                        ffprobe.stdout.on('data', (data) => output += data);
+                        ffprobe.on('close', () => {
+                            try {
+                                const info = JSON.parse(output);
+                                console.log(`🎞️ Video info: ${info.format.duration}s, ${info.streams[0].nb_frames} frames`);
+                            } catch (e) {
+                                console.log('📊 Video analysis failed, but file exists');
+                            }
+                        });
+                    }, 1000);
+                } else {
+                    console.log('⚠️ File size is very small - may not have content');
+                }
+            } else {
+                console.log('❌ Video file not found');
+            }
+        } else {
+            console.log('❌ Failed to start recording');
+        }
+    } catch (error) {
+        console.log('❌ Error during test:', error.message);
+    }
+}
+
+testPureScreenCaptureKit().catch(console.error);