node-mac-recorder 2.15.12 → 2.16.0

package/.claude/settings.local.json

@@ -42,7 +42,8 @@
       "Bash(ELECTRON_RUN_AS_NODE=1 node -e \"\nconsole.log(''🏁 Final stability test with all features'');\nconst MacRecorder = require(''./index'');\nconst recorder = new MacRecorder();\n\nasync function finalTest() {\n  try {\n    const outputPath = ''./test-output/final-stability-test.mov'';\n    console.log(''📹 Starting final stability test...'');\n    \n    const success = await recorder.startRecording(outputPath, {\n      captureCursor: true,\n      includeMicrophone: false,\n      includeSystemAudio: true,\n      captureArea: {\n        x: 200,\n        y: 200,\n        width: 600,\n        height: 400\n      }\n    });\n    \n    if (success) {\n      console.log(''✅ Recording started - waiting 4 seconds'');\n      await new Promise(resolve => setTimeout(resolve, 4000));\n      \n      console.log(''🛑 Stopping recording...'');\n      await recorder.stopRecording();\n      console.log(''🎉 FINAL TEST COMPLETED SUCCESSFULLY - NO CRASH!'');\n    } else {\n      console.log(''❌ Recording failed to start'');\n    }\n  } catch (error) {\n    console.log(''❌ Error:'', error.message);\n  }\n}\n\nfinalTest();\n\")",
       "Bash(ELECTRON_RUN_AS_NODE=1 node -e \"\nconsole.log(''🎵 Testing both microphone and system audio'');\nconst MacRecorder = require(''./index'');\nconst recorder = new MacRecorder();\n\nasync function testBothAudio() {\n  try {\n    const outputPath = ''./test-output/both-audio-test.mov'';\n    console.log(''📹 Starting recording with both audio sources...'');\n    \n    const success = await recorder.startRecording(outputPath, {\n      captureCursor: true,\n      includeMicrophone: true,   // Mikrophone AÇIK\n      includeSystemAudio: true   // Sistem sesi AÇIK\n    });\n    \n    if (success) {\n      console.log(''✅ Recording started - waiting 5 seconds'');\n      await new Promise(resolve => setTimeout(resolve, 5000));\n      \n      console.log(''🛑 Stopping recording...'');\n      await recorder.stopRecording();\n      console.log(''✅ Both audio test completed!'');\n    } else {\n      console.log(''❌ Recording failed to start'');\n    }\n  } catch (error) {\n    console.log(''❌ Error:'', error.message);\n    console.log(''Stack:'', error.stack);\n  }\n}\n\ntestBothAudio();\n\")",
       "Bash(ELECTRON_RUN_AS_NODE=1 node -e \"\nconsole.log(''🎤 Testing microphone only'');\nconst MacRecorder = require(''./index'');\nconst recorder = new MacRecorder();\n\nasync function testMicrophoneOnly() {\n  try {\n    const outputPath = ''./test-output/microphone-only-test.mov'';\n    console.log(''📹 Starting microphone only recording...'');\n    \n    const success = await recorder.startRecording(outputPath, {\n      captureCursor: false,\n      includeMicrophone: true,   // Sadece mikrofon AÇIK\n      includeSystemAudio: false  // Sistem sesi KAPALI\n    });\n    \n    if (success) {\n      console.log(''✅ Microphone recording started - waiting 3 seconds'');\n      await new Promise(resolve => setTimeout(resolve, 3000));\n      \n      console.log(''🛑 Stopping microphone recording...'');\n      await recorder.stopRecording();\n      console.log(''✅ Microphone only test completed!'');\n    } else {\n      console.log(''❌ Recording failed to start'');\n    }\n  } catch (error) {\n    console.log(''❌ Error:'', error.message);\n  }\n}\n\ntestMicrophoneOnly();\n\")",
-      "Bash(ELECTRON_RUN_AS_NODE=1 node -e \"\nconsole.log(''🚀 Full stress test - All features + Both audio sources'');\nconst MacRecorder = require(''./index'');\nconst recorder = new MacRecorder();\n\nasync function fullStressTest() {\n  try {\n    const outputPath = ''./test-output/full-stress-test.mov'';\n    console.log(''📹 Starting full featured recording (stress test)...'');\n    \n    const success = await recorder.startRecording(outputPath, {\n      captureCursor: true,       // Cursor kayıt\n      includeMicrophone: true,   // Mikrofon kayıt\n      includeSystemAudio: true,  // Sistem sesi kayıt\n      captureArea: {             // Crop area\n        x: 300,\n        y: 300,\n        width: 800,\n        height: 500\n      }\n    });\n    \n    if (success) {\n      console.log(''✅ Full stress test started - waiting 6 seconds'');\n      await new Promise(resolve => setTimeout(resolve, 6000));\n      \n      console.log(''🛑 Stopping full stress test...'');\n      await recorder.stopRecording();\n      console.log(''🎉 FULL STRESS TEST COMPLETED WITHOUT CRASH!'');\n    } else {\n      console.log(''❌ Recording failed to start'');\n    }\n  } catch (error) {\n    console.log(''❌ Error:'', error.message);\n    console.log(''Stack:'', error.stack);\n  }\n}\n\nfullStressTest();\n\")"
+      "Bash(ELECTRON_RUN_AS_NODE=1 node -e \"\nconsole.log(''🚀 Full stress test - All features + Both audio sources'');\nconst MacRecorder = require(''./index'');\nconst recorder = new MacRecorder();\n\nasync function fullStressTest() {\n  try {\n    const outputPath = ''./test-output/full-stress-test.mov'';\n    console.log(''📹 Starting full featured recording (stress test)...'');\n    \n    const success = await recorder.startRecording(outputPath, {\n      captureCursor: true,       // Cursor kayıt\n      includeMicrophone: true,   // Mikrofon kayıt\n      includeSystemAudio: true,  // Sistem sesi kayıt\n      captureArea: {             // Crop area\n        x: 300,\n        y: 300,\n        width: 800,\n        height: 500\n      }\n    });\n    \n    if (success) {\n      console.log(''✅ Full stress test started - waiting 6 seconds'');\n      await new Promise(resolve => setTimeout(resolve, 6000));\n      \n      console.log(''🛑 Stopping full stress test...'');\n      await recorder.stopRecording();\n      console.log(''🎉 FULL STRESS TEST COMPLETED WITHOUT CRASH!'');\n    } else {\n      console.log(''❌ Recording failed to start'');\n    }\n  } catch (error) {\n    console.log(''❌ Error:'', error.message);\n    console.log(''Stack:'', error.stack);\n  }\n}\n\nfullStressTest();\n\")",
+      "Bash(ELECTRON_RUN_AS_NODE=1 node -e \"\nconsole.log(''🧪 Testing version detection and fallback system'');\nconst MacRecorder = require(''./index'');\nconst recorder = new MacRecorder();\n\nasync function testVersionDetection() {\n  try {\n    const outputPath = ''./test-output/version-detection-test.mov'';\n    console.log(''📹 Starting recording with version detection...'');\n    \n    const success = await recorder.startRecording(outputPath, {\n      captureCursor: true,\n      includeMicrophone: false,\n      includeSystemAudio: true\n    });\n    \n    if (success) {\n      console.log(''✅ Recording started - waiting 3 seconds'');\n      await new Promise(resolve => setTimeout(resolve, 3000));\n      \n      console.log(''🛑 Stopping recording...'');\n      await recorder.stopRecording();\n      console.log(''✅ Version detection test completed successfully!'');\n    } else {\n      console.log(''❌ Recording failed to start'');\n    }\n  } catch (error) {\n    console.log(''❌ Error:'', error.message);\n  }\n}\n\ntestVersionDetection();\n\")"
     ],
     "deny": []
   }

package/binding.gyp

@@ -5,6 +5,7 @@
       "sources": [
         "src/mac_recorder.mm",
         "src/screen_capture_kit.mm",
+        "src/avfoundation_recorder.mm",
         "src/audio_capture.mm",
         "src/cursor_tracker.mm",
         "src/window_selector.mm"
@@ -30,6 +31,10 @@
           "-framework Foundation",
           "-framework AppKit",
           "-framework ScreenCaptureKit",
+          "-framework AVFoundation",
+          "-framework CoreMedia",
+          "-framework CoreVideo",
+          "-framework QuartzCore",
           "-framework ApplicationServices",
           "-framework Carbon",
           "-framework Accessibility",

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -0,0 +1,222 @@
+#import <Foundation/Foundation.h>
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMedia/CoreMedia.h>
+#import <CoreVideo/CoreVideo.h>
+#import <QuartzCore/QuartzCore.h>
+#import <AppKit/AppKit.h>
+#include <string>
+
+static AVAssetWriter *g_avWriter = nil;
+static AVAssetWriterInput *g_avVideoInput = nil;
+static AVAssetWriterInputPixelBufferAdaptor *g_avPixelBufferAdaptor = nil;
+static dispatch_source_t g_avTimer = nil;
+static CGDirectDisplayID g_avDisplayID = 0;
+static CGRect g_avCaptureRect = CGRectZero;
+static bool g_avIsRecording = false;
+static int64_t g_avFrameNumber = 0;
+static CMTime g_avStartTime;
+
+// AVFoundation screen recording implementation
+bool startAVFoundationRecording(const std::string& outputPath, 
+                               CGDirectDisplayID displayID,
+                               uint32_t windowID,
+                               CGRect captureRect,
+                               bool captureCursor,
+                               bool includeMicrophone, 
+                               bool includeSystemAudio,
+                               NSString* audioDeviceId) {
+    
+    if (g_avIsRecording) {
+        NSLog(@"❌ AVFoundation recording already in progress");
+        return false;
+    }
+    
+    @try {
+        // Create output URL
+        NSString *outputPathStr = [NSString stringWithUTF8String:outputPath.c_str()];
+        NSURL *outputURL = [NSURL fileURLWithPath:outputPathStr];
+        
+        // Remove existing file
+        [[NSFileManager defaultManager] removeItemAtURL:outputURL error:nil];
+        
+        // Create asset writer
+        NSError *error = nil;
+        g_avWriter = [[AVAssetWriter alloc] initWithURL:outputURL fileType:AVFileTypeQuickTimeMovie error:&error];
+        if (!g_avWriter || error) {
+            NSLog(@"❌ Failed to create AVAssetWriter: %@", error);
+            return false;
+        }
+        
+        // Get display dimensions
+        CGRect displayBounds = CGDisplayBounds(displayID);
+        CGSize recordingSize = captureRect.size.width > 0 ? captureRect.size : displayBounds.size;
+        
+        // Video settings
+        NSDictionary *videoSettings = @{
+            AVVideoCodecKey: AVVideoCodecTypeH264,
+            AVVideoWidthKey: @((int)recordingSize.width),
+            AVVideoHeightKey: @((int)recordingSize.height),
+            AVVideoCompressionPropertiesKey: @{
+                AVVideoAverageBitRateKey: @(recordingSize.width * recordingSize.height * 8),
+                AVVideoMaxKeyFrameIntervalKey: @30
+            }
+        };
+        
+        // Create video input
+        g_avVideoInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo outputSettings:videoSettings];
+        g_avVideoInput.expectsMediaDataInRealTime = YES;
+        
+        // Create pixel buffer adaptor
+        NSDictionary *pixelBufferAttributes = @{
+            (NSString*)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32ARGB),
+            (NSString*)kCVPixelBufferWidthKey: @((int)recordingSize.width),
+            (NSString*)kCVPixelBufferHeightKey: @((int)recordingSize.height),
+            (NSString*)kCVPixelBufferCGImageCompatibilityKey: @YES,
+            (NSString*)kCVPixelBufferCGBitmapContextCompatibilityKey: @YES
+        };
+        
+        g_avPixelBufferAdaptor = [AVAssetWriterInputPixelBufferAdaptor assetWriterInputPixelBufferAdaptorWithAssetWriterInput:g_avVideoInput sourcePixelBufferAttributes:pixelBufferAttributes];
+        
+        // Add input to writer
+        if (![g_avWriter canAddInput:g_avVideoInput]) {
+            NSLog(@"❌ Cannot add video input to AVAssetWriter");
+            return false;
+        }
+        [g_avWriter addInput:g_avVideoInput];
+        
+        // Start writing
+        if (![g_avWriter startWriting]) {
+            NSLog(@"❌ Failed to start AVAssetWriter: %@", g_avWriter.error);
+            return false;
+        }
+        
+        g_avStartTime = CMTimeMakeWithSeconds(CACurrentMediaTime(), 600);
+        [g_avWriter startSessionAtSourceTime:g_avStartTime];
+        
+        // Store recording parameters
+        g_avDisplayID = displayID;
+        g_avCaptureRect = captureRect;
+        g_avFrameNumber = 0;
+        
+        // Start capture timer (15 FPS for compatibility)
+        dispatch_queue_t captureQueue = dispatch_queue_create("AVFoundationCaptureQueue", DISPATCH_QUEUE_SERIAL);
+        g_avTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, captureQueue);
+        
+        uint64_t interval = NSEC_PER_SEC / 15; // 15 FPS
+        dispatch_source_set_timer(g_avTimer, dispatch_time(DISPATCH_TIME_NOW, 0), interval, interval / 10);
+        
+        dispatch_source_set_event_handler(g_avTimer, ^{
+            if (!g_avIsRecording) return;
+            
+            @autoreleasepool {
+                // Capture screen
+                CGImageRef screenImage = nil;
+                if (CGRectIsEmpty(g_avCaptureRect)) {
+                    screenImage = CGDisplayCreateImage(g_avDisplayID);
+                } else {
+                    CGImageRef fullScreen = CGDisplayCreateImage(g_avDisplayID);
+                    if (fullScreen) {
+                        screenImage = CGImageCreateWithImageInRect(fullScreen, g_avCaptureRect);
+                        CGImageRelease(fullScreen);
+                    }
+                }
+                
+                if (!screenImage) return;
+                
+                // Convert to pixel buffer
+                CVPixelBufferRef pixelBuffer = nil;
+                CVReturn cvRet = CVPixelBufferPoolCreatePixelBuffer(NULL, g_avPixelBufferAdaptor.pixelBufferPool, &pixelBuffer);
+                
+                if (cvRet == kCVReturnSuccess && pixelBuffer) {
+                    CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+                    
+                    void *pixelData = CVPixelBufferGetBaseAddress(pixelBuffer);
+                    size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+                    
+                    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+                    CGContextRef context = CGBitmapContextCreate(pixelData, 
+                                                               CVPixelBufferGetWidth(pixelBuffer),
+                                                               CVPixelBufferGetHeight(pixelBuffer), 
+                                                               8, bytesPerRow, colorSpace,
+                                                               kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little);
+                    
+                    if (context) {
+                        CGContextDrawImage(context, CGRectMake(0, 0, CVPixelBufferGetWidth(pixelBuffer), CVPixelBufferGetHeight(pixelBuffer)), screenImage);
+                        CGContextRelease(context);
+                    }
+                    CGColorSpaceRelease(colorSpace);
+                    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+                    
+                    // Write frame
+                    if (g_avVideoInput.readyForMoreMediaData) {
+                        CMTime frameTime = CMTimeAdd(g_avStartTime, CMTimeMakeWithSeconds(g_avFrameNumber / 15.0, 600));
+                        [g_avPixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:frameTime];
+                        g_avFrameNumber++;
+                    }
+                    
+                    CVPixelBufferRelease(pixelBuffer);
+                }
+                
+                CGImageRelease(screenImage);
+            }
+        });
+        
+        dispatch_resume(g_avTimer);
+        g_avIsRecording = true;
+        
+        NSLog(@"🎥 AVFoundation recording started: %dx%d @ 15fps", 
+              (int)recordingSize.width, (int)recordingSize.height);
+        
+        return true;
+        
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Exception in AVFoundation recording: %@", exception.reason);
+        return false;
+    }
+}
+
+bool stopAVFoundationRecording() {
+    if (!g_avIsRecording) {
+        return true;
+    }
+    
+    g_avIsRecording = false;
+    
+    @try {
+        // Stop timer
+        if (g_avTimer) {
+            dispatch_source_cancel(g_avTimer);
+            g_avTimer = nil;
+        }
+        
+        // Finish writing
+        if (g_avVideoInput) {
+            [g_avVideoInput markAsFinished];
+        }
+        
+        if (g_avWriter && g_avWriter.status == AVAssetWriterStatusWriting) {
+            dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+            [g_avWriter finishWritingWithCompletionHandler:^{
+                dispatch_semaphore_signal(semaphore);
+            }];
+            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+        }
+        
+        // Cleanup
+        g_avWriter = nil;
+        g_avVideoInput = nil;
+        g_avPixelBufferAdaptor = nil;
+        g_avFrameNumber = 0;
+        
+        NSLog(@"✅ AVFoundation recording stopped");
+        return true;
+        
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Exception stopping AVFoundation recording: %@", exception.reason);
+        return false;
+    }
+}
+
+bool isAVFoundationRecording() {
+    return g_avIsRecording;
+}

package/src/mac_recorder.mm

@@ -8,6 +8,20 @@
 // Import screen capture (ScreenCaptureKit only)
 #import "screen_capture_kit.h"
 
+// AVFoundation fallback declarations
+extern "C" {
+    bool startAVFoundationRecording(const std::string& outputPath, 
+                                   CGDirectDisplayID displayID,
+                                   uint32_t windowID,
+                                   CGRect captureRect,
+                                   bool captureCursor,
+                                   bool includeMicrophone, 
+                                   bool includeSystemAudio,
+                                   NSString* audioDeviceId);
+    bool stopAVFoundationRecording();
+    bool isAVFoundationRecording();
+}
+
 // Cursor tracker function declarations
 Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports);
 
@@ -30,12 +44,18 @@ static bool g_isRecording = false;
 
 // Helper function to cleanup recording resources
 void cleanupRecording() {
-    // ScreenCaptureKit cleanup only
+    // ScreenCaptureKit cleanup
     if (@available(macOS 12.3, *)) {
         if ([ScreenCaptureKitRecorder isRecording]) {
             [ScreenCaptureKitRecorder stopRecording];
         }
     }
+    
+    // AVFoundation cleanup
+    if (isAVFoundationRecording()) {
+        stopAVFoundationRecording();
+    }
+    
     g_isRecording = false;
 }
 
@@ -164,18 +184,24 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             NSLog(@"⚠️ Warning: ScreenCaptureKit in Electron may require additional stability measures");
         }
         
-        // Non-Electron: Use ScreenCaptureKit
-        if (@available(macOS 12.3, *)) {
-            NSLog(@"✅ macOS 12.3+ detected - ScreenCaptureKit should be available");
-            
-            // Check if running in Electron environment
-            BOOL isElectron = (getenv("ELECTRON_RUN_AS_NODE") != NULL || 
-                              [[NSProcessInfo processInfo].processName containsString:@"Electron"] ||
-                              [[NSBundle mainBundle].bundleIdentifier containsString:@"electron"]);
+        // Check macOS version for ScreenCaptureKit compatibility
+        NSOperatingSystemVersion osVersion = [[NSProcessInfo processInfo] operatingSystemVersion];
+        BOOL isM15Plus = (osVersion.majorVersion > 15 || 
+                          (osVersion.majorVersion == 15 && osVersion.minorVersion >= 0));
+        BOOL isM14Plus = (osVersion.majorVersion > 14 || 
+                          (osVersion.majorVersion == 14 && osVersion.minorVersion >= 0));
+        
+        NSLog(@"🖥️ macOS Version: %ld.%ld.%ld", 
+              (long)osVersion.majorVersion, (long)osVersion.minorVersion, (long)osVersion.patchVersion);
+        
+        // Try ScreenCaptureKit on macOS 14+ (with better compatibility on 15+)
+        if (@available(macOS 12.3, *) && isM14Plus) {
+            NSLog(@"✅ macOS 14+ detected - ScreenCaptureKit available with %@ compatibility", 
+                  isM15Plus ? @"full" : @"limited");
             
-            // Try ScreenCaptureKit with extensive safety measures (skip in Electron due to compatibility issues)
+            // Try ScreenCaptureKit with extensive safety measures
             @try {
-                if (!isElectron && [ScreenCaptureKitRecorder isScreenCaptureKitAvailable]) {
+                if ([ScreenCaptureKitRecorder isScreenCaptureKitAvailable]) {
                     NSLog(@"✅ ScreenCaptureKit availability check passed");
                     NSLog(@"🎯 Using ScreenCaptureKit - overlay windows will be automatically excluded");
                     
@@ -234,25 +260,49 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                     }
                     
                     NSLog(@"❌ ScreenCaptureKit failed or unsafe");
-                    // Fall through to AVFoundation
+                    
                 } else {
-                    NSLog(@"❌ ScreenCaptureKit not available - falling back to AVFoundation");
+                    NSLog(@"❌ ScreenCaptureKit availability check failed");
+                    NSLog(@"❌ ScreenCaptureKit not available");
                 }
             } @catch (NSException *availabilityException) {
-                NSLog(@"⚠️ Exception during ScreenCaptureKit check: %@", availabilityException.reason);
-                if (isElectron) {
-                    NSLog(@"🔄 Expected in Electron - using AVFoundation fallback");
-                } else {
-                    NSLog(@"🔄 Falling back to AVFoundation");
-                }
+                NSLog(@"❌ Exception during ScreenCaptureKit availability check: %@", availabilityException.reason);
+                return Napi::Boolean::New(env, false);
             }
         } else {
-            NSLog(@"⚠️ macOS version < 12.3 - ScreenCaptureKit not available, falling back to AVFoundation");
+            NSLog(@"❌ macOS version too old for ScreenCaptureKit (< 12.3) - Recording not supported");
+            return Napi::Boolean::New(env, false);
+        }
+        
+        // If we get here, ScreenCaptureKit failed - try AVFoundation fallback
+        NSLog(@"🔄 ScreenCaptureKit failed - attempting AVFoundation fallback");
+        
+        @try {
+            // Import AVFoundation recording functions (if available)
+            extern bool startAVFoundationRecording(const std::string& outputPath, 
+                                                   CGDirectDisplayID displayID,
+                                                   uint32_t windowID,
+                                                   CGRect captureRect,
+                                                   bool captureCursor,
+                                                   bool includeMicrophone, 
+                                                   bool includeSystemAudio,
+                                                   NSString* audioDeviceId);
+            
+            if (startAVFoundationRecording(outputPath, displayID, windowID, captureRect, 
+                                          captureCursor, includeMicrophone, includeSystemAudio, audioDeviceId)) {
+                NSLog(@"🎥 RECORDING METHOD: AVFoundation (Fallback)");
+                NSLog(@"✅ AVFoundation recording started successfully");
+                g_isRecording = true;
+                return Napi::Boolean::New(env, true);
+            } else {
+                NSLog(@"❌ AVFoundation recording also failed to start");
+            }
+        } @catch (NSException *avException) {
+            NSLog(@"❌ Exception during AVFoundation startup: %@", avException.reason);
         }
         
-        // If we get here, ScreenCaptureKit failed - use AVFoundation fallback
-        NSLog(@"🔄 ScreenCaptureKit failed - using AVFoundation fallback");
-        NSLog(@"❌ AVFoundation recording not implemented in this version");
+        // Both ScreenCaptureKit and AVFoundation failed
+        NSLog(@"❌ All recording methods failed - no recording available");
         return Napi::Boolean::New(env, false);
         
     } @catch (NSException *exception) {
@@ -267,22 +317,39 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     
     NSLog(@"📞 StopRecording native method called");
     
-    // ScreenCaptureKit ONLY
+    // Try ScreenCaptureKit first
     if (@available(macOS 12.3, *)) {
         if ([ScreenCaptureKitRecorder isRecording]) {
             NSLog(@"🛑 Stopping ScreenCaptureKit recording");
             [ScreenCaptureKitRecorder stopRecording];
             g_isRecording = false;
             return Napi::Boolean::New(env, true);
-        } else {
-            NSLog(@"⚠️ ScreenCaptureKit not recording");
-            g_isRecording = false;
-            return Napi::Boolean::New(env, true);
         }
-    } else {
-        NSLog(@"❌ ScreenCaptureKit not available - cannot stop recording");
-        return Napi::Boolean::New(env, false);
     }
+    
+    // Try AVFoundation fallback
+    extern bool isAVFoundationRecording();
+    extern bool stopAVFoundationRecording();
+    
+    @try {
+        if (isAVFoundationRecording()) {
+            NSLog(@"🛑 Stopping AVFoundation recording");
+            if (stopAVFoundationRecording()) {
+                g_isRecording = false;
+                return Napi::Boolean::New(env, true);
+            } else {
+                NSLog(@"❌ Failed to stop AVFoundation recording");
+                g_isRecording = false;
+                return Napi::Boolean::New(env, false);
+            }
+        }
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Exception stopping AVFoundation: %@", exception.reason);
+    }
+    
+    NSLog(@"⚠️ No active recording found to stop");
+    g_isRecording = false;
+    return Napi::Boolean::New(env, true);
 }
 
 
@@ -538,7 +605,21 @@ Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
 // NAPI Function: Get Recording Status
 Napi::Value GetRecordingStatus(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-    return Napi::Boolean::New(env, g_isRecording);
+    
+    // Check both recording methods
+    bool isRecording = g_isRecording;
+    
+    if (@available(macOS 12.3, *)) {
+        if ([ScreenCaptureKitRecorder isRecording]) {
+            isRecording = true;
+        }
+    }
+    
+    if (isAVFoundationRecording()) {
+        isRecording = true;
+    }
+    
+    return Napi::Boolean::New(env, isRecording);
 }
 
 // NAPI Function: Get Window Thumbnail

package/src/screen_capture_kit.mm

@@ -121,25 +121,15 @@ static NSString *g_outputPath = nil;
             
             if (displayId && [displayId integerValue] != 0) {
                 // Find specific display
-                NSLog(@"🔍 Looking for display ID: %@", displayId);
-                NSLog(@"📋 Available displays:");
                 for (SCDisplay *display in content.displays) {
-                    NSLog(@"  - Display %u: %dx%d", display.displayID, (int)display.width, (int)display.height);
                     if (display.displayID == [displayId unsignedIntValue]) {
                         targetDisplay = display;
-                        NSLog(@"✅ Found matching display %u", display.displayID);
                         break;
                     }
                 }
-                
-                if (!targetDisplay) {
-                    NSLog(@"❌ Display ID %@ not found in ScreenCaptureKit displays", displayId);
-                    NSLog(@"🔧 Available IDs: %@", [content.displays valueForKey:@"displayID"]);
-                }
             } else {
                 // Use first display
                 targetDisplay = content.displays.firstObject;
-                NSLog(@"📺 Using first available display: %u", targetDisplay.displayID);
             }
             
             if (!targetDisplay) {

package/test-display-id-debug.js

@@ -1,42 +0,0 @@
-const MacRecorder = require('./index');
-
-async function testDisplayIdDebug() {
-    console.log('🔍 Testing display ID debugging...');
-    
-    const recorder = new MacRecorder();
-    const displays = await recorder.getDisplays();
-    
-    console.log('📊 JavaScript display IDs:');
-    displays.forEach(display => {
-        console.log(`  ${display.name}: ID=${display.id} ${display.isPrimary ? '[PRIMARY]' : ''}`);
-    });
-    
-    // Test recording on secondary display to trigger the debug logs
-    const secondaryDisplay = displays.find(d => !d.isPrimary);
-    if (secondaryDisplay) {
-        console.log(`\n🎯 Testing recording on ${secondaryDisplay.name} (ID: ${secondaryDisplay.id})`);
-        
-        try {
-            await recorder.startRecording('./test-output/display-id-debug.mov', {
-                displayId: secondaryDisplay.id,
-                captureCursor: true,
-                includeMicrophone: false,
-                includeSystemAudio: false
-            });
-            
-            console.log('✅ Recording started - check native logs for display ID matching');
-            
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            
-            await recorder.stopRecording();
-            console.log('✅ Recording completed');
-            
-        } catch (error) {
-            console.log(`❌ Recording failed: ${error.message}`);
-        }
-    } else {
-        console.log('⚠️ No secondary display found');
-    }
-}
-
-testDisplayIdDebug();

package/test-electron-env.js

@@ -1,38 +0,0 @@
-const MacRecorder = require('./index');
-
-// Simulate Electron environment
-process.env.ELECTRON_RUN_AS_NODE = '1';
-
-async function testElectronFallback() {
-    console.log('🔋 Testing Electron environment fallback...');
-    console.log('Environment variables:');
-    console.log('  ELECTRON_RUN_AS_NODE:', process.env.ELECTRON_RUN_AS_NODE);
-    
-    const recorder = new MacRecorder();
-    
-    try {
-        console.log('\n🎯 Attempting to start recording in simulated Electron environment...');
-        
-        await recorder.startRecording('./test-output/electron-fallback-test.mov', {
-            displayId: 1,
-            captureCursor: true,
-            includeMicrophone: false,
-            includeSystemAudio: false
-        });
-        
-        console.log('✅ Recording started (unexpected - should have failed)');
-        
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        
-        await recorder.stopRecording();
-        console.log('✅ Recording completed');
-        
-    } catch (error) {
-        console.log(`❌ Recording failed as expected in Electron: ${error.message}`);
-    }
-}
-
-testElectronFallback().finally(() => {
-    // Clean up
-    delete process.env.ELECTRON_RUN_AS_NODE;
-});