node-mac-recorder 2.15.0 → 2.15.2

package/src/electron_safe/audio_capture_electron.mm

@@ -0,0 +1,137 @@
+#import <napi.h>
+#import <AVFoundation/AVFoundation.h>
+#import <CoreAudio/CoreAudio.h>
+
+// Thread-safe audio device management for Electron
+static dispatch_queue_t g_audioQueue = nil;
+
+static void initializeAudioQueue() {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        g_audioQueue = dispatch_queue_create("com.macrecorder.audio.electron", DISPATCH_QUEUE_SERIAL);
+    });
+}
+
+// NAPI Function: Get Audio Devices (Electron-safe)
+Napi::Value GetAudioDevicesElectronSafe(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        initializeAudioQueue();
+        
+        __block NSArray *devices = nil;
+        
+        dispatch_sync(g_audioQueue, ^{
+            @try {
+                NSMutableArray *audioDevices = [NSMutableArray array];
+                
+                // Get all audio devices
+                AudioObjectPropertyAddress propertyAddress = {
+                    kAudioHardwarePropertyDevices,
+                    kAudioObjectPropertyScopeGlobal,
+                    kAudioObjectPropertyElementMaster
+                };
+                
+                UInt32 dataSize = 0;
+                OSStatus status = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, 
+                                                               &propertyAddress, 
+                                                               0, 
+                                                               NULL, 
+                                                               &dataSize);
+                
+                if (status == noErr && dataSize > 0) {
+                    UInt32 deviceCount = dataSize / sizeof(AudioDeviceID);
+                    AudioDeviceID *audioDeviceIDs = (AudioDeviceID*)malloc(dataSize);
+                    
+                    status = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                                       &propertyAddress,
+                                                       0,
+                                                       NULL,
+                                                       &dataSize,
+                                                       audioDeviceIDs);
+                    
+                    if (status == noErr) {
+                        for (UInt32 i = 0; i < deviceCount; i++) {
+                            AudioDeviceID deviceID = audioDeviceIDs[i];
+                            
+                            // Get device name
+                            CFStringRef deviceName = NULL;
+                            UInt32 nameSize = sizeof(CFStringRef);
+                            AudioObjectPropertyAddress nameAddress = {
+                                kAudioDevicePropertyDeviceNameCFString,
+                                kAudioObjectPropertyScopeGlobal,
+                                kAudioObjectPropertyElementMaster
+                            };
+                            
+                            status = AudioObjectGetPropertyData(deviceID,
+                                                               &nameAddress,
+                                                               0,
+                                                               NULL,
+                                                               &nameSize,
+                                                               &deviceName);
+                            
+                            if (status == noErr && deviceName) {
+                                NSString *name = (__bridge NSString*)deviceName;
+                                
+                                NSDictionary *deviceInfo = @{
+                                    @"id": @(deviceID),
+                                    @"name": name,
+                                    @"type": @"Audio Device"
+                                };
+                                
+                                [audioDevices addObject:deviceInfo];
+                                CFRelease(deviceName);
+                            }
+                        }
+                    }
+                    
+                    free(audioDeviceIDs);
+                }
+                
+                devices = [audioDevices copy];
+                
+            } @catch (NSException *e) {
+                NSLog(@"❌ Exception getting audio devices: %@", e.reason);
+                devices = @[];
+            }
+        });
+        
+        Napi::Array result = Napi::Array::New(env, devices ? devices.count : 0);
+        
+        if (devices) {
+            for (NSUInteger i = 0; i < devices.count; i++) {
+                NSDictionary *device = devices[i];
+                Napi::Object deviceObj = Napi::Object::New(env);
+                
+                deviceObj.Set("id", Napi::Number::New(env, [device[@"id"] unsignedIntValue]));
+                deviceObj.Set("name", Napi::String::New(env, [device[@"name"] UTF8String]));
+                deviceObj.Set("type", Napi::String::New(env, [device[@"type"] UTF8String]));
+                
+                result.Set(i, deviceObj);
+            }
+        }
+        
+        return result;
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Fatal exception in GetAudioDevicesElectronSafe: %@", e.reason);
+        Napi::Error::New(env, "Failed to get audio devices").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+// Initialize audio capture module
+Napi::Object InitAudioCaptureElectron(Napi::Env env, Napi::Object exports) {
+    @try {
+        initializeAudioQueue();
+        
+        exports.Set("getAudioDevices", Napi::Function::New(env, GetAudioDevicesElectronSafe));
+        
+        NSLog(@"✅ Electron-safe audio capture initialized");
+        return exports;
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Exception initializing audio capture: %@", e.reason);
+        return exports;
+    }
+}

package/src/electron_safe/cursor_tracker_electron.mm

@@ -0,0 +1,90 @@
+#import <napi.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <AppKit/AppKit.h>
+
+// Thread-safe cursor tracking for Electron
+static dispatch_queue_t g_cursorQueue = nil;
+
+static void initializeCursorQueue() {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        g_cursorQueue = dispatch_queue_create("com.macrecorder.cursor.electron", DISPATCH_QUEUE_SERIAL);
+    });
+}
+
+// NAPI Function: Get Cursor Position (Electron-safe)
+Napi::Value GetCursorPositionElectronSafe(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        initializeCursorQueue();
+        
+        __block CGPoint mouseLocation = CGPointZero;
+        __block NSString *cursorType = @"arrow";
+        
+        dispatch_sync(g_cursorQueue, ^{
+            @try {
+                // Get mouse location
+                mouseLocation = [NSEvent mouseLocation];
+                
+                // Convert to screen coordinates (flip Y)
+                NSArray *screens = [NSScreen screens];
+                if (screens.count > 0) {
+                    NSScreen *mainScreen = screens[0];
+                    CGFloat screenHeight = mainScreen.frame.size.height;
+                    mouseLocation.y = screenHeight - mouseLocation.y;
+                }
+                
+                // Get cursor type safely
+                NSCursor *currentCursor = [NSCursor currentCursor];
+                if (currentCursor) {
+                    if (currentCursor == [NSCursor arrowCursor]) {
+                        cursorType = @"arrow";
+                    } else if (currentCursor == [NSCursor IBeamCursor]) {
+                        cursorType = @"ibeam";
+                    } else if (currentCursor == [NSCursor pointingHandCursor]) {
+                        cursorType = @"hand";
+                    } else if (currentCursor == [NSCursor resizeLeftRightCursor]) {
+                        cursorType = @"resize-horizontal";
+                    } else if (currentCursor == [NSCursor resizeUpDownCursor]) {
+                        cursorType = @"resize-vertical";
+                    } else {
+                        cursorType = @"default";
+                    }
+                }
+                
+            } @catch (NSException *e) {
+                NSLog(@"❌ Exception getting cursor position: %@", e.reason);
+            }
+        });
+        
+        Napi::Object result = Napi::Object::New(env);
+        result.Set("x", Napi::Number::New(env, mouseLocation.x));
+        result.Set("y", Napi::Number::New(env, mouseLocation.y));
+        result.Set("cursorType", Napi::String::New(env, [cursorType UTF8String]));
+        result.Set("eventType", Napi::String::New(env, "move"));
+        
+        return result;
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Fatal exception in GetCursorPositionElectronSafe: %@", e.reason);
+        Napi::Error::New(env, "Failed to get cursor position").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+// Initialize cursor tracker module
+Napi::Object InitCursorTrackerElectron(Napi::Env env, Napi::Object exports) {
+    @try {
+        initializeCursorQueue();
+        
+        exports.Set("getCursorPosition", Napi::Function::New(env, GetCursorPositionElectronSafe));
+        
+        NSLog(@"✅ Electron-safe cursor tracker initialized");
+        return exports;
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Exception initializing cursor tracker: %@", e.reason);
+        return exports;
+    }
+}

package/src/electron_safe/mac_recorder_electron.mm

@@ -0,0 +1,337 @@
+#import <napi.h>
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMedia/CoreMedia.h>
+#import <AppKit/AppKit.h>
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <ImageIO/ImageIO.h>
+#import <CoreAudio/CoreAudio.h>
+
+// Electron-safe screen capture headers
+#import "screen_capture_electron.h"
+
+// Forward declarations for other modules
+Napi::Object InitCursorTrackerElectron(Napi::Env env, Napi::Object exports);
+Napi::Object InitWindowSelectorElectron(Napi::Env env, Napi::Object exports);
+
+// Thread-safe recording state with proper synchronization
+@interface ElectronSafeRecordingState : NSObject
+@property (atomic) BOOL isRecording;
+@property (atomic, strong) NSString *outputPath;
+@property (atomic, strong) NSDate *startTime;
++ (instancetype)sharedState;
+- (void)resetState;
+@end
+
+@implementation ElectronSafeRecordingState
++ (instancetype)sharedState {
+    static ElectronSafeRecordingState *shared = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        shared = [[ElectronSafeRecordingState alloc] init];
+    });
+    return shared;
+}
+
+- (instancetype)init {
+    if (self = [super init]) {
+        [self resetState];
+    }
+    return self;
+}
+
+- (void)resetState {
+    self.isRecording = NO;
+    self.outputPath = nil;
+    self.startTime = nil;
+}
+@end
+
+// Electron-safe cleanup function
+void electronSafeCleanup() {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        @try {
+            [[ElectronSafeRecordingState sharedState] resetState];
+            
+            // Stop any active recording safely
+            if (@available(macOS 12.3, *)) {
+                [ElectronSafeScreenCapture stopRecordingSafely];
+            }
+        } @catch (NSException *e) {
+            NSLog(@"⚠️ Safe cleanup exception: %@", e.reason);
+        }
+    });
+}
+
+// NAPI Function: Electron-safe Start Recording
+Napi::Value StartRecordingElectronSafe(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        if (info.Length() < 1) {
+            Napi::TypeError::New(env, "Output path required").ThrowAsJavaScriptException();
+            return env.Null();
+        }
+        
+        ElectronSafeRecordingState *state = [ElectronSafeRecordingState sharedState];
+        
+        if (state.isRecording) {
+            NSLog(@"⚠️ Recording already in progress");
+            return Napi::Boolean::New(env, false);
+        }
+        
+        std::string outputPath = info[0].As<Napi::String>().Utf8Value();
+        
+        // Parse options safely
+        NSDictionary *options = @{};
+        if (info.Length() > 1 && info[1].IsObject()) {
+            Napi::Object optionsObj = info[1].As<Napi::Object>();
+            NSMutableDictionary *mutableOptions = [NSMutableDictionary dictionary];
+            
+            // Extract options with proper type checking
+            if (optionsObj.Has("captureCursor")) {
+                mutableOptions[@"captureCursor"] = @(optionsObj.Get("captureCursor").As<Napi::Boolean>().Value());
+            }
+            if (optionsObj.Has("includeMicrophone")) {
+                mutableOptions[@"includeMicrophone"] = @(optionsObj.Get("includeMicrophone").As<Napi::Boolean>().Value());
+            }
+            if (optionsObj.Has("includeSystemAudio")) {
+                mutableOptions[@"includeSystemAudio"] = @(optionsObj.Get("includeSystemAudio").As<Napi::Boolean>().Value());
+            }
+            if (optionsObj.Has("displayId")) {
+                mutableOptions[@"displayId"] = @(optionsObj.Get("displayId").As<Napi::Number>().Uint32Value());
+            }
+            if (optionsObj.Has("windowId")) {
+                mutableOptions[@"windowId"] = @(optionsObj.Get("windowId").As<Napi::Number>().Uint32Value());
+            }
+            
+            // Capture area with bounds checking
+            if (optionsObj.Has("captureArea") && optionsObj.Get("captureArea").IsObject()) {
+                Napi::Object areaObj = optionsObj.Get("captureArea").As<Napi::Object>();
+                if (areaObj.Has("x") && areaObj.Has("y") && areaObj.Has("width") && areaObj.Has("height")) {
+                    double x = areaObj.Get("x").As<Napi::Number>().DoubleValue();
+                    double y = areaObj.Get("y").As<Napi::Number>().DoubleValue();
+                    double width = areaObj.Get("width").As<Napi::Number>().DoubleValue();
+                    double height = areaObj.Get("height").As<Napi::Number>().DoubleValue();
+                    
+                    // Validate bounds
+                    if (width > 0 && height > 0 && x >= 0 && y >= 0) {
+                        mutableOptions[@"captureArea"] = @{
+                            @"x": @(x),
+                            @"y": @(y),
+                            @"width": @(width),
+                            @"height": @(height)
+                        };
+                    }
+                }
+            }
+            
+            options = [mutableOptions copy];
+        }
+        
+        // Start recording on main queue for Electron safety
+        __block BOOL success = NO;
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            @try {
+                NSString *nsOutputPath = [NSString stringWithUTF8String:outputPath.c_str()];
+                
+                if (@available(macOS 12.3, *)) {
+                    success = [ElectronSafeScreenCapture startRecordingWithPath:nsOutputPath options:options];
+                } else {
+                    NSLog(@"❌ ScreenCaptureKit not available on this macOS version");
+                    success = NO;
+                }
+                
+                if (success) {
+                    state.isRecording = YES;
+                    state.outputPath = nsOutputPath;
+                    state.startTime = [NSDate date];
+                    NSLog(@"✅ Electron-safe recording started: %@", nsOutputPath);
+                }
+            } @catch (NSException *e) {
+                NSLog(@"❌ Recording start exception: %@", e.reason);
+                success = NO;
+            }
+        });
+        
+        return Napi::Boolean::New(env, success);
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Fatal exception in StartRecordingElectronSafe: %@", e.reason);
+        electronSafeCleanup();
+        Napi::Error::New(env, "Native recording failed").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+// NAPI Function: Electron-safe Stop Recording
+Napi::Value StopRecordingElectronSafe(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        ElectronSafeRecordingState *state = [ElectronSafeRecordingState sharedState];
+        
+        if (!state.isRecording) {
+            NSLog(@"⚠️ No recording in progress");
+            return Napi::Boolean::New(env, false);
+        }
+        
+        __block BOOL success = NO;
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            @try {
+                if (@available(macOS 12.3, *)) {
+                    success = [ElectronSafeScreenCapture stopRecordingSafely];
+                }
+                
+                // Always reset state
+                [state resetState];
+                
+                NSLog(@"✅ Electron-safe recording stopped");
+            } @catch (NSException *e) {
+                NSLog(@"❌ Recording stop exception: %@", e.reason);
+                [state resetState]; // Reset state even on error
+                success = NO;
+            }
+        });
+        
+        return Napi::Boolean::New(env, success);
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Fatal exception in StopRecordingElectronSafe: %@", e.reason);
+        electronSafeCleanup();
+        Napi::Error::New(env, "Native stop recording failed").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+// NAPI Function: Get Recording Status (Electron-safe)
+Napi::Value GetRecordingStatusElectronSafe(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        ElectronSafeRecordingState *state = [ElectronSafeRecordingState sharedState];
+        
+        Napi::Object status = Napi::Object::New(env);
+        status.Set("isRecording", Napi::Boolean::New(env, state.isRecording));
+        
+        if (state.outputPath) {
+            status.Set("outputPath", Napi::String::New(env, [state.outputPath UTF8String]));
+        }
+        
+        if (state.startTime) {
+            NSTimeInterval elapsed = [[NSDate date] timeIntervalSinceDate:state.startTime];
+            status.Set("elapsedTime", Napi::Number::New(env, elapsed));
+        }
+        
+        return status;
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Fatal exception in GetRecordingStatusElectronSafe: %@", e.reason);
+        Napi::Error::New(env, "Failed to get status").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+// NAPI Function: Get Displays (Electron-safe)
+Napi::Value GetDisplaysElectronSafe(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        __block NSArray *displays = nil;
+        
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            @try {
+                displays = [ElectronSafeScreenCapture getAvailableDisplays];
+            } @catch (NSException *e) {
+                NSLog(@"❌ Exception getting displays: %@", e.reason);
+            }
+        });
+        
+        if (!displays) {
+            return Napi::Array::New(env, 0);
+        }
+        
+        Napi::Array result = Napi::Array::New(env, displays.count);
+        for (NSUInteger i = 0; i < displays.count; i++) {
+            NSDictionary *display = displays[i];
+            Napi::Object displayObj = Napi::Object::New(env);
+            
+            displayObj.Set("id", Napi::Number::New(env, [display[@"id"] unsignedIntValue]));
+            displayObj.Set("name", Napi::String::New(env, [display[@"name"] UTF8String]));
+            displayObj.Set("width", Napi::Number::New(env, [display[@"width"] intValue]));
+            displayObj.Set("height", Napi::Number::New(env, [display[@"height"] intValue]));
+            displayObj.Set("x", Napi::Number::New(env, [display[@"x"] intValue]));
+            displayObj.Set("y", Napi::Number::New(env, [display[@"y"] intValue]));
+            displayObj.Set("isPrimary", Napi::Boolean::New(env, [display[@"isPrimary"] boolValue]));
+            
+            result.Set(i, displayObj);
+        }
+        
+        return result;
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Fatal exception in GetDisplaysElectronSafe: %@", e.reason);
+        Napi::Error::New(env, "Failed to get displays").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+// NAPI Function: Check Permissions (Electron-safe)
+Napi::Value CheckPermissionsElectronSafe(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        __block BOOL hasPermission = NO;
+        
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            @try {
+                hasPermission = [ElectronSafeScreenCapture checkPermissions];
+            } @catch (NSException *e) {
+                NSLog(@"❌ Exception checking permissions: %@", e.reason);
+            }
+        });
+        
+        return Napi::Boolean::New(env, hasPermission);
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Fatal exception in CheckPermissionsElectronSafe: %@", e.reason);
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// Module initialization for Electron
+Napi::Object InitElectronSafe(Napi::Env env, Napi::Object exports) {
+    @try {
+        NSLog(@"🔌 Initializing Electron-safe mac-recorder module");
+        
+        // Export Electron-safe functions
+        exports.Set("startRecording", Napi::Function::New(env, StartRecordingElectronSafe));
+        exports.Set("stopRecording", Napi::Function::New(env, StopRecordingElectronSafe));
+        exports.Set("getRecordingStatus", Napi::Function::New(env, GetRecordingStatusElectronSafe));
+        exports.Set("getDisplays", Napi::Function::New(env, GetDisplaysElectronSafe));
+        exports.Set("checkPermissions", Napi::Function::New(env, CheckPermissionsElectronSafe));
+        
+        // Initialize sub-modules safely
+        @try {
+            InitCursorTrackerElectron(env, exports);
+        } @catch (NSException *e) {
+            NSLog(@"⚠️ Cursor tracker initialization failed: %@", e.reason);
+        }
+        
+        @try {
+            InitWindowSelectorElectron(env, exports);
+        } @catch (NSException *e) {
+            NSLog(@"⚠️ Window selector initialization failed: %@", e.reason);
+        }
+        
+        NSLog(@"✅ Electron-safe module initialized successfully");
+        return exports;
+        
+    } @catch (NSException *e) {
+        NSLog(@"❌ Fatal exception during module initialization: %@", e.reason);
+        return exports;
+    }
+}
+
+// Register the module
+NODE_API_MODULE(mac_recorder_electron, InitElectronSafe)

package/src/electron_safe/screen_capture_electron.h

@@ -0,0 +1,30 @@
+#ifndef SCREEN_CAPTURE_ELECTRON_H
+#define SCREEN_CAPTURE_ELECTRON_H
+
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <ScreenCaptureKit/ScreenCaptureKit.h>
+
+@interface ElectronSafeScreenCapture : NSObject
+
+// Core recording functions
++ (BOOL)startRecordingWithPath:(NSString *)outputPath options:(NSDictionary *)options;
++ (BOOL)stopRecordingSafely;
++ (BOOL)isRecording;
+
+// Information functions
++ (NSArray *)getAvailableDisplays;
++ (NSArray *)getAvailableWindows;
++ (BOOL)checkPermissions;
+
+// Thumbnail functions
++ (NSString *)getDisplayThumbnailBase64:(CGDirectDisplayID)displayID 
+                               maxWidth:(NSInteger)maxWidth 
+                              maxHeight:(NSInteger)maxHeight;
++ (NSString *)getWindowThumbnailBase64:(uint32_t)windowID 
+                              maxWidth:(NSInteger)maxWidth 
+                             maxHeight:(NSInteger)maxHeight;
+
+@end
+
+#endif // SCREEN_CAPTURE_ELECTRON_H