node-mac-recorder 2.15.13 → 2.16.1

package/.claude/settings.local.json

@@ -42,7 +42,9 @@
       "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\")",
+      "Bash(ELECTRON_RUN_AS_NODE=1 node -e \"\nconsole.log(''🧪 Testing Electron safety measures'');\nconst MacRecorder = require(''./index'');\nconst recorder = new MacRecorder();\n\nasync function testElectronSafety() {\n  try {\n    const outputPath = ''./test-output/electron-safe-test.mov'';\n    console.log(''📹 Starting recording in Electron environment...'');\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 safely in Electron - waiting 3 seconds'');\n      await new Promise(resolve => setTimeout(resolve, 3000));\n      \n      console.log(''🛑 Stopping recording...'');\n      await recorder.stopRecording();\n      console.log(''✅ Electron safety test completed successfully!'');\n    } else {\n      console.log(''⚠️ Recording failed to start (expected in some cases)'');\n    }\n  } catch (error) {\n    console.log(''❌ Error:'', error.message);\n  }\n}\n\ntestElectronSafety();\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.13",
+	"version": "2.16.1",
 	"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,24 @@ 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 (only in non-Electron environments)
+    BOOL isElectron = (NSBundle.mainBundle.bundleIdentifier && 
+                      [NSBundle.mainBundle.bundleIdentifier containsString:@"electron"]) ||
+                     (NSProcessInfo.processInfo.processName && 
+                      [NSProcessInfo.processInfo.processName containsString:@"Electron"]) ||
+                     (NSProcessInfo.processInfo.environment[@"ELECTRON_RUN_AS_NODE"] != nil);
+    
+    if (!isElectron && isAVFoundationRecording()) {
+        stopAVFoundationRecording();
+    }
+    
     g_isRecording = false;
 }
 
@@ -164,9 +190,20 @@ 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 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
             @try {
@@ -243,8 +280,42 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             return Napi::Boolean::New(env, false);
         }
         
-        // If we get here, ScreenCaptureKit failed completely
-        NSLog(@"❌ ScreenCaptureKit failed to initialize - Recording not available");
+        // If we get here, ScreenCaptureKit failed
+        if (isElectron) {
+            NSLog(@"❌ ScreenCaptureKit failed in Electron - AVFoundation disabled for stability");
+            NSLog(@"❌ Recording not available in Electron when ScreenCaptureKit fails");
+            return Napi::Boolean::New(env, false);
+        }
+        
+        // Try AVFoundation fallback (only in non-Electron environments)
+        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);
+        }
+        
+        // Both ScreenCaptureKit and AVFoundation failed
+        NSLog(@"❌ All recording methods failed - no recording available");
         return Napi::Boolean::New(env, false);
         
     } @catch (NSException *exception) {
@@ -259,22 +330,47 @@ 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 (only in non-Electron environments)
+    BOOL isElectron = (NSBundle.mainBundle.bundleIdentifier && 
+                      [NSBundle.mainBundle.bundleIdentifier containsString:@"electron"]) ||
+                     (NSProcessInfo.processInfo.processName && 
+                      [NSProcessInfo.processInfo.processName containsString:@"Electron"]) ||
+                     (NSProcessInfo.processInfo.environment[@"ELECTRON_RUN_AS_NODE"] != nil);
+    
+    if (!isElectron) {
+        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);
 }
 
 
@@ -530,7 +626,28 @@ 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 recording methods
+    bool isRecording = g_isRecording;
+    
+    if (@available(macOS 12.3, *)) {
+        if ([ScreenCaptureKitRecorder isRecording]) {
+            isRecording = true;
+        }
+    }
+    
+    // Check AVFoundation only in non-Electron environments
+    BOOL isElectron = (NSBundle.mainBundle.bundleIdentifier && 
+                      [NSBundle.mainBundle.bundleIdentifier containsString:@"electron"]) ||
+                     (NSProcessInfo.processInfo.processName && 
+                      [NSProcessInfo.processInfo.processName containsString:@"Electron"]) ||
+                     (NSProcessInfo.processInfo.environment[@"ELECTRON_RUN_AS_NODE"] != nil);
+    
+    if (!isElectron && isAVFoundationRecording()) {
+        isRecording = true;
+    }
+    
+    return Napi::Boolean::New(env, isRecording);
 }
 
 // NAPI Function: Get Window Thumbnail