node-mac-recorder 2.2.1 → 2.4.1

package/src/mac_recorder.mm

@@ -1,10 +1,7 @@
 #import <napi.h>
 #import <ScreenCaptureKit/ScreenCaptureKit.h>
-<<<<<<< HEAD
-=======
 #import <AVFoundation/AVFoundation.h>
 #import <CoreMedia/CoreMedia.h>
->>>>>>> screencapture
 #import <AppKit/AppKit.h>
 #import <Foundation/Foundation.h>
 #import <CoreGraphics/CoreGraphics.h>
@@ -21,13 +18,9 @@ Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports);
 // Window selector function declarations
 Napi::Object InitWindowSelector(Napi::Env env, Napi::Object exports);
 
-<<<<<<< HEAD
-@interface MacRecorderDelegate : NSObject
-=======
 // ScreenCaptureKit Recording Delegate
 API_AVAILABLE(macos(12.3))
 @interface SCKRecorderDelegate : NSObject <SCStreamDelegate, SCStreamOutput>
->>>>>>> screencapture
 @property (nonatomic, copy) void (^completionHandler)(NSURL *outputURL, NSError *error);
 @property (nonatomic, copy) void (^startedHandler)(void);
 @property (nonatomic, strong) AVAssetWriter *assetWriter;
@@ -41,20 +34,6 @@ API_AVAILABLE(macos(12.3))
 @property (nonatomic, assign) BOOL startFailed;
 @end
 
-<<<<<<< HEAD
-@implementation MacRecorderDelegate
-- (void)recordingDidStart {
-    NSLog(@"[mac_recorder] ScreenCaptureKit recording started");
-}
-- (void)recordingDidFinish:(NSURL *)outputURL error:(NSError *)error {
-    if (error) {
-        NSLog(@"[mac_recorder] ScreenCaptureKit recording finished with error: %@", error.localizedDescription);
-    } else {
-        NSLog(@"[mac_recorder] ScreenCaptureKit recording finished OK → %@", outputURL.path);
-    }
-    if (self.completionHandler) {
-        self.completionHandler(outputURL, error);
-=======
 @implementation SCKRecorderDelegate
 
 // Standard SCStreamDelegate method - should be called automatically
@@ -67,7 +46,6 @@ API_AVAILABLE(macos(12.3))
     NSLog(@"🛑 Stream stopped with error: %@", error ? error.localizedDescription : @"none");
     if (self.completionHandler) {
         self.completionHandler(self.outputURL, error);
->>>>>>> screencapture
     }
 }
 
@@ -142,42 +120,75 @@ API_AVAILABLE(macos(12.3))
 
 @end
 
-<<<<<<< HEAD
-// Global state for recording
-static MacRecorderDelegate *g_delegate = nil;
-static bool g_isRecording = false;
-
-// Helper function to cleanup recording resources
-void cleanupRecording() {
-    g_delegate = nil;
-=======
 // Global state for ScreenCaptureKit recording
 static SCStream *g_scStream = nil;
 static SCKRecorderDelegate *g_scDelegate = nil;
 static bool g_isRecording = false;
+static BOOL g_screenOutputAttached = NO;
+static BOOL g_audioOutputAttached = NO;
+static dispatch_queue_t g_outputQueue = NULL; // use a dedicated serial queue for sample handling
 
 // Helper function to cleanup ScreenCaptureKit recording resources
 void cleanupSCKRecording() {
     NSLog(@"🛑 Cleaning up ScreenCaptureKit recording");
-    
+
+    // Detach outputs first to prevent further callbacks into the delegate
+    if (g_scStream && g_scDelegate) {
+        NSError *rmError = nil;
+        if (g_screenOutputAttached) {
+            [g_scStream removeStreamOutput:g_scDelegate type:SCStreamOutputTypeScreen error:&rmError];
+            g_screenOutputAttached = NO;
+        }
+        if (g_audioOutputAttached) {
+            rmError = nil;
+            [g_scStream removeStreamOutput:g_scDelegate type:SCStreamOutputTypeAudio error:&rmError];
+            g_audioOutputAttached = NO;
+        }
+    }
+
     if (g_scStream) {
         NSLog(@"🛑 Stopping SCStream");
-        [g_scStream stopCaptureWithCompletionHandler:^(NSError * _Nullable error) {
+        SCStream *streamToStop = g_scStream; // keep local until stop completes
+        [streamToStop stopCaptureWithCompletionHandler:^(NSError * _Nullable error) {
             if (error) {
                 NSLog(@"❌ Error stopping SCStream: %@", error.localizedDescription);
             } else {
                 NSLog(@"✅ SCStream stopped successfully");
             }
+
+            // Finish writer after stream has stopped to ensure no further buffers arrive
+            if (g_scDelegate && g_scDelegate.assetWriter && g_scDelegate.isWriting) {
+                NSLog(@"🛑 Finishing asset writer (status: %ld)", (long)g_scDelegate.assetWriter.status);
+                g_scDelegate.isWriting = NO;
+
+                if (g_scDelegate.assetWriter.status == AVAssetWriterStatusWriting) {
+                    if (g_scDelegate.videoInput) {
+                        [g_scDelegate.videoInput markAsFinished];
+                    }
+                    if (g_scDelegate.audioInput) {
+                        [g_scDelegate.audioInput markAsFinished];
+                    }
+
+                    [g_scDelegate.assetWriter finishWritingWithCompletionHandler:^{
+                        NSLog(@"✅ Asset writer finished. Status: %ld", (long)g_scDelegate.assetWriter.status);
+                        if (g_scDelegate.assetWriter.error) {
+                            NSLog(@"❌ Asset writer error: %@", g_scDelegate.assetWriter.error.localizedDescription);
+                        }
+                    }];
+                } else if (g_scDelegate.assetWriter.status == AVAssetWriterStatusFailed) {
+                    NSLog(@"❌ Asset writer failed: %@", g_scDelegate.assetWriter.error.localizedDescription);
+                }
+            }
+
+            g_isRecording = false;
+            g_scStream = nil;
+            g_scDelegate = nil;
         }];
-        g_scStream = nil;
-    }
-    
-    if (g_scDelegate) {
-        if (g_scDelegate.assetWriter && g_scDelegate.isWriting) {
+    } else {
+        // No stream, just finalize writer if needed
+        if (g_scDelegate && g_scDelegate.assetWriter && g_scDelegate.isWriting) {
             NSLog(@"🛑 Finishing asset writer (status: %ld)", (long)g_scDelegate.assetWriter.status);
             g_scDelegate.isWriting = NO;
-            
-            // Only mark inputs as finished if asset writer is actually writing
             if (g_scDelegate.assetWriter.status == AVAssetWriterStatusWriting) {
                 if (g_scDelegate.videoInput) {
                     [g_scDelegate.videoInput markAsFinished];
@@ -185,24 +196,12 @@ void cleanupSCKRecording() {
                 if (g_scDelegate.audioInput) {
                     [g_scDelegate.audioInput markAsFinished];
                 }
-                
-                [g_scDelegate.assetWriter finishWritingWithCompletionHandler:^{
-                    NSLog(@"✅ Asset writer finished. Status: %ld", (long)g_scDelegate.assetWriter.status);
-                    if (g_scDelegate.assetWriter.error) {
-                        NSLog(@"❌ Asset writer error: %@", g_scDelegate.assetWriter.error.localizedDescription);
-                    }
-                }];
-            } else {
-                NSLog(@"⚠️ Asset writer not in writing status, cannot finish normally");
-                if (g_scDelegate.assetWriter.status == AVAssetWriterStatusFailed) {
-                    NSLog(@"❌ Asset writer failed: %@", g_scDelegate.assetWriter.error.localizedDescription);
-                }
+                [g_scDelegate.assetWriter finishWritingWithCompletionHandler:^{}];
             }
         }
+        g_isRecording = false;
         g_scDelegate = nil;
     }
->>>>>>> screencapture
-    g_isRecording = false;
 }
 
 // Check if ScreenCaptureKit is available
@@ -216,7 +215,7 @@ bool isScreenCaptureKitAvailable() {
 // NAPI Function: Start Recording with ScreenCaptureKit
 Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
-    
+    @autoreleasepool {
     if (!isScreenCaptureKitAvailable()) {
         NSLog(@"ScreenCaptureKit requires macOS 12.3 or later");
         return Napi::Boolean::New(env, false);
@@ -246,31 +245,13 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     NSLog(@"✅ Screen recording permission verified");
     
     std::string outputPath = info[0].As<Napi::String>().Utf8Value();
-    NSLog(@"[mac_recorder] StartRecording: output=%@", [NSString stringWithUTF8String:outputPath.c_str()]);
     
-<<<<<<< HEAD
-    // Options parsing (shared)
-    CGRect captureRect = CGRectNull;
-    bool captureCursor = false; // Default olarak cursor gizli
-    bool includeMicrophone = false; // Default olarak mikrofon kapalı
-    bool includeSystemAudio = true; // Default olarak sistem sesi açık
-    CGDirectDisplayID displayID = CGMainDisplayID(); // Default ana ekran
-    NSString *audioDeviceId = nil; // Default audio device ID
-    NSString *systemAudioDeviceId = nil; // System audio device ID
-    bool forceUseSC = false;
-    // Exclude options for ScreenCaptureKit (optional, backward compatible)
-    NSMutableArray<NSString*> *excludedAppBundleIds = [NSMutableArray array];
-    NSMutableArray<NSNumber*> *excludedPIDs = [NSMutableArray array];
-    NSMutableArray<NSNumber*> *excludedWindowIds = [NSMutableArray array];
-    bool autoExcludeSelf = false;
-=======
     // Default options
     bool captureCursor = false;
     bool includeSystemAudio = true;
     CGDirectDisplayID displayID = 0; // Will be set to first available display
     uint32_t windowID = 0;
     CGRect captureRect = CGRectNull;
->>>>>>> screencapture
     
     // Parse options
     if (info.Length() > 1 && info[1].IsObject()) {
@@ -285,53 +266,6 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             includeSystemAudio = options.Get("includeSystemAudio").As<Napi::Boolean>();
         }
         
-<<<<<<< HEAD
-        // System audio device ID
-        if (options.Has("systemAudioDeviceId") && !options.Get("systemAudioDeviceId").IsNull()) {
-            std::string sysDeviceId = options.Get("systemAudioDeviceId").As<Napi::String>().Utf8Value();
-            systemAudioDeviceId = [NSString stringWithUTF8String:sysDeviceId.c_str()];
-        }
-
-        // ScreenCaptureKit toggle (optional)
-        if (options.Has("useScreenCaptureKit")) {
-            forceUseSC = options.Get("useScreenCaptureKit").As<Napi::Boolean>();
-        }
-
-        // Exclusion lists (optional)
-        if (options.Has("excludedAppBundleIds") && options.Get("excludedAppBundleIds").IsArray()) {
-            Napi::Array arr = options.Get("excludedAppBundleIds").As<Napi::Array>();
-            for (uint32_t i = 0; i < arr.Length(); i++) {
-                if (!arr.Get(i).IsUndefined() && !arr.Get(i).IsNull()) {
-                    std::string s = arr.Get(i).As<Napi::String>().Utf8Value();
-                    [excludedAppBundleIds addObject:[NSString stringWithUTF8String:s.c_str()]];
-                }
-            }
-        }
-        if (options.Has("excludedPIDs") && options.Get("excludedPIDs").IsArray()) {
-            Napi::Array arr = options.Get("excludedPIDs").As<Napi::Array>();
-            for (uint32_t i = 0; i < arr.Length(); i++) {
-                if (!arr.Get(i).IsUndefined() && !arr.Get(i).IsNull()) {
-                    double v = arr.Get(i).As<Napi::Number>().DoubleValue();
-                    [excludedPIDs addObject:@( (pid_t)v )];
-                }
-            }
-        }
-        if (options.Has("excludedWindowIds") && options.Get("excludedWindowIds").IsArray()) {
-            Napi::Array arr = options.Get("excludedWindowIds").As<Napi::Array>();
-            for (uint32_t i = 0; i < arr.Length(); i++) {
-                if (!arr.Get(i).IsUndefined() && !arr.Get(i).IsNull()) {
-                    double v = arr.Get(i).As<Napi::Number>().DoubleValue();
-                    [excludedWindowIds addObject:@( (uint32_t)v )];
-                }
-            }
-        }
-        if (options.Has("autoExcludeSelf")) {
-            autoExcludeSelf = options.Get("autoExcludeSelf").As<Napi::Boolean>();
-        }
-        
-        // Display ID
-=======
->>>>>>> screencapture
         if (options.Has("displayId") && !options.Get("displayId").IsNull()) {
             uint32_t tempDisplayID = options.Get("displayId").As<Napi::Number>().Uint32Value();
             if (tempDisplayID != 0) {
@@ -356,64 +290,6 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         }
     }
     
-<<<<<<< HEAD
-    @try {
-        // Always prefer ScreenCaptureKit if available
-        NSLog(@"[mac_recorder] Checking ScreenCaptureKit availability");
-        if (@available(macOS 12.3, *)) {
-            if ([ScreenCaptureKitRecorder isScreenCaptureKitAvailable]) {
-            NSMutableDictionary *scConfig = [@{} mutableCopy];
-            scConfig[@"displayId"] = @(displayID);
-            if (!CGRectIsNull(captureRect)) {
-                scConfig[@"captureArea"] = @{ @"x": @(captureRect.origin.x),
-                                               @"y": @(captureRect.origin.y),
-                                               @"width": @(captureRect.size.width),
-                                               @"height": @(captureRect.size.height) };
-            }
-            scConfig[@"captureCursor"] = @(captureCursor);
-            scConfig[@"includeMicrophone"] = @(includeMicrophone);
-            scConfig[@"includeSystemAudio"] = @(includeSystemAudio);
-            if (excludedAppBundleIds.count) scConfig[@"excludedAppBundleIds"] = excludedAppBundleIds;
-            if (excludedPIDs.count) scConfig[@"excludedPIDs"] = excludedPIDs;
-            if (excludedWindowIds.count) scConfig[@"excludedWindowIds"] = excludedWindowIds;
-            // Auto exclude current app by PID if requested
-            if (autoExcludeSelf) {
-                pid_t pid = getpid();
-                NSMutableArray *arr = [NSMutableArray arrayWithArray:scConfig[@"excludedPIDs"] ?: @[]];
-                [arr addObject:@(pid)];
-                scConfig[@"excludedPIDs"] = arr;
-            }
-
-            // Output path for SC
-            std::string outputPathStr = info[0].As<Napi::String>().Utf8Value();
-            scConfig[@"outputPath"] = [NSString stringWithUTF8String:outputPathStr.c_str()];
-
-            NSError *scErr = nil;
-            NSLog(@"[mac_recorder] Using ScreenCaptureKit path (displayId=%u)", displayID);
-            
-            // Create and set up delegate
-            g_delegate = [[MacRecorderDelegate alloc] init];
-            
-            BOOL ok = [ScreenCaptureKitRecorder startRecordingWithConfiguration:scConfig delegate:g_delegate error:&scErr];
-            if (ok) {
-                g_isRecording = true;
-                NSLog(@"[mac_recorder] ScreenCaptureKit startRecording → OK");
-                return Napi::Boolean::New(env, true);
-            }
-            NSLog(@"[mac_recorder] ScreenCaptureKit startRecording → FAIL: %@", scErr.localizedDescription);
-            cleanupRecording();
-            return Napi::Boolean::New(env, false);
-            }
-        } else {
-            NSLog(@"[mac_recorder] ScreenCaptureKit not available");
-            cleanupRecording();
-            return Napi::Boolean::New(env, false);
-        }
-        
-    } @catch (NSException *exception) {
-        cleanupRecording();
-        return Napi::Boolean::New(env, false);
-=======
     // Create output URL
     NSURL *outputURL = [NSURL fileURLWithPath:[NSString stringWithUTF8String:outputPath.c_str()]];
     NSLog(@"📁 Output URL: %@", outputURL.absoluteString);
@@ -543,13 +419,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         
         contentFilter = [[SCContentFilter alloc] initWithDisplay:targetDisplay excludingWindows:excluded];
         NSLog(@"✅ Content filter created for display recording");
->>>>>>> screencapture
     }
     
-<<<<<<< HEAD
-    if (!g_isRecording) {
-        return Napi::Boolean::New(env, false);
-=======
     // Get actual display dimensions for proper video configuration
     CGRect displayBounds = CGDisplayBounds(displayID);
     NSSize videoSize = NSMakeSize(displayBounds.size.width, displayBounds.size.height);
@@ -571,27 +442,9 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         NSLog(@"🔊 Audio configuration: capture=%@, excludeProcess=%@", includeSystemAudio ? @"YES" : @"NO", @"YES");
     } else {
         NSLog(@"⚠️ macOS 13.0+ features not available");
->>>>>>> screencapture
     }
     config.showsCursor = captureCursor;
     
-<<<<<<< HEAD
-    @try {
-        NSLog(@"[mac_recorder] StopRecording called");
-        
-        // Stop ScreenCaptureKit recording
-        NSLog(@"[mac_recorder] Stopping ScreenCaptureKit stream");
-        if (@available(macOS 12.3, *)) {
-            [ScreenCaptureKitRecorder stopRecording];
-        }
-        g_isRecording = false;
-        cleanupRecording();
-        NSLog(@"[mac_recorder] ScreenCaptureKit stopped");
-        return Napi::Boolean::New(env, true);
-        
-    } @catch (NSException *exception) {
-        cleanupRecording();
-=======
     if (!CGRectIsNull(captureRect)) {
         config.sourceRect = captureRect;
         // Update video size if capture rect is specified
@@ -611,7 +464,6 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     
     if (writerError) {
         NSLog(@"❌ Failed to create asset writer: %@", writerError.localizedDescription);
->>>>>>> screencapture
         return Napi::Boolean::New(env, false);
     }
     
@@ -635,117 +487,6 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         NSLog(@"❌ Cannot add video input to asset writer");
     }
     
-<<<<<<< HEAD
-    @try {
-        NSMutableArray *devices = [NSMutableArray array];
-        
-        // Use CoreAudio to get audio devices since we're removing AVFoundation
-        AudioObjectPropertyAddress propertyAddress = {
-            kAudioHardwarePropertyDevices,
-            kAudioObjectPropertyScopeGlobal,
-            kAudioObjectPropertyElementMain
-        };
-        
-        UInt32 dataSize = 0;
-        OSStatus status = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &propertyAddress, 0, NULL, &dataSize);
-        if (status != noErr) {
-            return Napi::Array::New(env, 0);
-        }
-        
-        UInt32 deviceCount = dataSize / sizeof(AudioDeviceID);
-        AudioDeviceID *audioDevices = (AudioDeviceID *)malloc(dataSize);
-        
-        status = AudioObjectGetPropertyData(kAudioObjectSystemObject, &propertyAddress, 0, NULL, &dataSize, audioDevices);
-        if (status != noErr) {
-            free(audioDevices);
-            return Napi::Array::New(env, 0);
-        }
-        
-        for (UInt32 i = 0; i < deviceCount; i++) {
-            AudioDeviceID deviceID = audioDevices[i];
-            
-            // Check if device has input streams
-            AudioObjectPropertyAddress streamsAddress = {
-                kAudioDevicePropertyStreams,
-                kAudioDevicePropertyScopeInput,
-                kAudioObjectPropertyElementMain
-            };
-            
-            UInt32 streamsSize = 0;
-            status = AudioObjectGetPropertyDataSize(deviceID, &streamsAddress, 0, NULL, &streamsSize);
-            if (status != noErr || streamsSize == 0) {
-                continue; // Skip output-only devices
-            }
-            
-            // Get device name
-            AudioObjectPropertyAddress nameAddress = {
-                kAudioDevicePropertyDeviceNameCFString,
-                kAudioObjectPropertyScopeGlobal,
-                kAudioObjectPropertyElementMain
-            };
-            
-            CFStringRef deviceNameRef = NULL;
-            UInt32 nameSize = sizeof(CFStringRef);
-            status = AudioObjectGetPropertyData(deviceID, &nameAddress, 0, NULL, &nameSize, &deviceNameRef);
-            
-            NSString *deviceName = @"Unknown Device";
-            if (status == noErr && deviceNameRef) {
-                deviceName = (__bridge NSString *)deviceNameRef;
-            }
-            
-            // Get device UID
-            AudioObjectPropertyAddress uidAddress = {
-                kAudioDevicePropertyDeviceUID,
-                kAudioObjectPropertyScopeGlobal,
-                kAudioObjectPropertyElementMain
-            };
-            
-            CFStringRef deviceUIDRef = NULL;
-            UInt32 uidSize = sizeof(CFStringRef);
-            status = AudioObjectGetPropertyData(deviceID, &uidAddress, 0, NULL, &uidSize, &deviceUIDRef);
-            
-            NSString *deviceUID = [NSString stringWithFormat:@"%u", deviceID];
-            if (status == noErr && deviceUIDRef) {
-                deviceUID = (__bridge NSString *)deviceUIDRef;
-            }
-            
-            // Check if this is the default input device
-            AudioObjectPropertyAddress defaultAddress = {
-                kAudioHardwarePropertyDefaultInputDevice,
-                kAudioObjectPropertyScopeGlobal,
-                kAudioObjectPropertyElementMain
-            };
-            
-            AudioDeviceID defaultDeviceID = kAudioDeviceUnknown;
-            UInt32 defaultSize = sizeof(AudioDeviceID);
-            AudioObjectGetPropertyData(kAudioObjectSystemObject, &defaultAddress, 0, NULL, &defaultSize, &defaultDeviceID);
-            
-            BOOL isDefault = (deviceID == defaultDeviceID);
-            
-            [devices addObject:@{
-                @"id": deviceUID,
-                @"name": deviceName,
-                @"manufacturer": @"Unknown",
-                @"isDefault": @(isDefault)
-            }];
-            
-            if (deviceNameRef) CFRelease(deviceNameRef);
-            if (deviceUIDRef) CFRelease(deviceUIDRef);
-        }
-        
-        free(audioDevices);
-        
-        // Convert to NAPI array
-        Napi::Array result = Napi::Array::New(env, devices.count);
-        for (NSUInteger i = 0; i < devices.count; i++) {
-            NSDictionary *device = devices[i];
-            Napi::Object deviceObj = Napi::Object::New(env);
-            deviceObj.Set("id", Napi::String::New(env, [device[@"id"] UTF8String]));
-            deviceObj.Set("name", Napi::String::New(env, [device[@"name"] UTF8String]));
-            deviceObj.Set("manufacturer", Napi::String::New(env, [device[@"manufacturer"] UTF8String]));
-            deviceObj.Set("isDefault", Napi::Boolean::New(env, [device[@"isDefault"] boolValue]));
-            result[i] = deviceObj;
-=======
     // Audio input settings (if needed)
     if (includeSystemAudio) {
         NSDictionary *audioSettings = @{
@@ -762,19 +503,22 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         }
     }
     
-    // Create callback queue for the delegate
-    dispatch_queue_t delegateQueue = dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0);
-    
+    // Create a dedicated serial queue for output callbacks
+    if (g_outputQueue == NULL) {
+        g_outputQueue = dispatch_queue_create("com.node-mac-recorder.stream-output", DISPATCH_QUEUE_SERIAL);
+    }
+
     // Create and start stream first
     g_scStream = [[SCStream alloc] initWithFilter:contentFilter configuration:config delegate:g_scDelegate];
     
     // Attach outputs to actually receive sample buffers
     NSLog(@"✅ Setting up stream output callback for sample buffers");
-    dispatch_queue_t outputQueue = dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0);
+    dispatch_queue_t outputQueue = g_outputQueue;
     NSError *outputError = nil;
     BOOL addedScreenOutput = [g_scStream addStreamOutput:g_scDelegate type:SCStreamOutputTypeScreen sampleHandlerQueue:outputQueue error:&outputError];
     if (addedScreenOutput) {
         NSLog(@"✅ Screen output attached to SCStream");
+        g_screenOutputAttached = YES;
     } else {
         NSLog(@"❌ Failed to attach screen output to SCStream: %@", outputError.localizedDescription);
     }
@@ -783,9 +527,9 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         BOOL addedAudioOutput = [g_scStream addStreamOutput:g_scDelegate type:SCStreamOutputTypeAudio sampleHandlerQueue:outputQueue error:&outputError];
         if (addedAudioOutput) {
             NSLog(@"✅ Audio output attached to SCStream");
+            g_audioOutputAttached = YES;
         } else {
             NSLog(@"⚠️ Failed to attach audio output to SCStream (audio may be disabled): %@", outputError.localizedDescription);
->>>>>>> screencapture
         }
     }
     
@@ -837,6 +581,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     
     NSLog(@"🎬 Recording initialized successfully");
     return Napi::Boolean::New(env, true);
+    }
 }
 
 // NAPI Function: Stop Recording
@@ -851,6 +596,12 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     return Napi::Boolean::New(env, true);
 }
 
+// NAPI Function: Get Recording Status (for JS compatibility)
+Napi::Value GetRecordingStatus(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return Napi::Boolean::New(env, g_isRecording);
+}
+
 // NAPI Function: Get Recording Status
 Napi::Value IsRecording(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -950,19 +701,6 @@ Napi::Value GetWindows(const Napi::CallbackInfo& info) {
 Napi::Value CheckPermissions(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
-<<<<<<< HEAD
-    @try {
-        // Check screen recording permission using ScreenCaptureKit
-        bool hasScreenPermission = true;
-        
-        if (@available(macOS 12.3, *)) {
-            // Try to get shareable content to test ScreenCaptureKit permissions
-            @try {
-                SCShareableContent *content = [SCShareableContent currentShareableContent];
-                hasScreenPermission = (content != nil && content.displays.count > 0);
-            } @catch (NSException *exception) {
-                hasScreenPermission = false;
-=======
     // Check screen recording permission
     bool hasPermission = CGPreflightScreenCaptureAccess();
     
@@ -1032,41 +770,8 @@ Napi::Value GetAudioDevices(const Napi::CallbackInfo& info) {
                 
                 devices.Set(index++, deviceObj);
                 CFRelease(deviceName);
->>>>>>> screencapture
-            }
-        } else {
-            // Fallback for older macOS versions
-            if (@available(macOS 10.15, *)) {
-                // Try to create a display stream to test permissions
-                CGDisplayStreamRef stream = CGDisplayStreamCreate(
-                    CGMainDisplayID(), 
-                    1, 1, 
-                    kCVPixelFormatType_32BGRA, 
-                    nil, 
-                    ^(CGDisplayStreamFrameStatus status, uint64_t displayTime, IOSurfaceRef frameSurface, CGDisplayStreamUpdateRef updateRef) {
-                        // Empty handler
-                    }
-                );
-                
-                if (stream) {
-                    CFRelease(stream);
-                    hasScreenPermission = true;
-                } else {
-                    hasScreenPermission = false;
-                }
             }
         }
-<<<<<<< HEAD
-        
-        // For audio permission, we'll use a simpler check since we're using CoreAudio
-        bool hasAudioPermission = true;
-        
-        return Napi::Boolean::New(env, hasScreenPermission && hasAudioPermission);
-        
-    } @catch (NSException *exception) {
-        return Napi::Boolean::New(env, false);
-=======
->>>>>>> screencapture
     }
     
     free(audioDevices);
@@ -1075,37 +780,14 @@ Napi::Value GetAudioDevices(const Napi::CallbackInfo& info) {
 
 // Initialize the addon
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
-<<<<<<< HEAD
-    exports.Set(Napi::String::New(env, "startRecording"), Napi::Function::New(env, StartRecording));
-    exports.Set(Napi::String::New(env, "stopRecording"), Napi::Function::New(env, StopRecording));
-
-    exports.Set(Napi::String::New(env, "getAudioDevices"), Napi::Function::New(env, GetAudioDevices));
-    exports.Set(Napi::String::New(env, "getDisplays"), Napi::Function::New(env, GetDisplays));
-    exports.Set(Napi::String::New(env, "getWindows"), Napi::Function::New(env, GetWindows));
-    exports.Set(Napi::String::New(env, "getRecordingStatus"), Napi::Function::New(env, GetRecordingStatus));
-    exports.Set(Napi::String::New(env, "checkPermissions"), Napi::Function::New(env, CheckPermissions));
-    // ScreenCaptureKit availability (optional for clients)
-    exports.Set(Napi::String::New(env, "isScreenCaptureKitAvailable"), Napi::Function::New(env, [](const Napi::CallbackInfo& info){
-        Napi::Env env = info.Env();
-        if (@available(macOS 12.3, *)) {
-            bool available = [ScreenCaptureKitRecorder isScreenCaptureKitAvailable];
-            return Napi::Boolean::New(env, available);
-        }
-        return Napi::Boolean::New(env, false);
-    }));
-    
-    // Thumbnail functions
-    exports.Set(Napi::String::New(env, "getWindowThumbnail"), Napi::Function::New(env, GetWindowThumbnail));
-    exports.Set(Napi::String::New(env, "getDisplayThumbnail"), Napi::Function::New(env, GetDisplayThumbnail));
-=======
     exports.Set("startRecording", Napi::Function::New(env, StartRecording));
     exports.Set("stopRecording", Napi::Function::New(env, StopRecording));
     exports.Set("isRecording", Napi::Function::New(env, IsRecording));
+    exports.Set("getRecordingStatus", Napi::Function::New(env, GetRecordingStatus));
     exports.Set("getDisplays", Napi::Function::New(env, GetDisplays));
     exports.Set("getWindows", Napi::Function::New(env, GetWindows));
     exports.Set("checkPermissions", Napi::Function::New(env, CheckPermissions));
     exports.Set("getAudioDevices", Napi::Function::New(env, GetAudioDevices));
->>>>>>> screencapture
     
     // Initialize cursor tracker
     InitCursorTracker(env, exports);