node-mac-recorder 2.10.40 → 2.12.0

package/package.json

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

package/src/mac_recorder.mm

@@ -9,6 +9,7 @@
 
 // Import screen capture
 #import "screen_capture.h"
+#import "screen_capture_kit.h"
 
 // Cursor tracker function declarations
 Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports);
@@ -159,6 +160,46 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     }
     
     @try {
+        // Try ScreenCaptureKit first (macOS 12.3+)
+        if (@available(macOS 12.3, *)) {
+            if ([ScreenCaptureKitRecorder isScreenCaptureKitAvailable]) {
+                NSLog(@"🎯 Using ScreenCaptureKit - overlay windows will be automatically excluded");
+                
+                // Create configuration for ScreenCaptureKit
+                NSMutableDictionary *sckConfig = [NSMutableDictionary dictionary];
+                sckConfig[@"displayId"] = @(displayID);
+                sckConfig[@"captureCursor"] = @(captureCursor);
+                sckConfig[@"includeSystemAudio"] = @(includeSystemAudio);
+                sckConfig[@"includeMicrophone"] = @(includeMicrophone);
+                sckConfig[@"audioDeviceId"] = audioDeviceId;
+                sckConfig[@"outputPath"] = [NSString stringWithUTF8String:outputPath.c_str()];
+                
+                if (!CGRectIsNull(captureRect)) {
+                    sckConfig[@"captureRect"] = @{
+                        @"x": @(captureRect.origin.x),
+                        @"y": @(captureRect.origin.y),
+                        @"width": @(captureRect.size.width),
+                        @"height": @(captureRect.size.height)
+                    };
+                }
+                
+                // Use ScreenCaptureKit with window exclusion
+                NSError *sckError = nil;
+                if ([ScreenCaptureKitRecorder startRecordingWithConfiguration:sckConfig 
+                                                                     delegate:g_delegate 
+                                                                        error:&sckError]) {
+                    NSLog(@"✅ ScreenCaptureKit recording started with window exclusion");
+                    g_isRecording = true;
+                    return Napi::Boolean::New(env, true);
+                } else {
+                    NSLog(@"⚠️ ScreenCaptureKit failed (%@), falling back to AVFoundation", sckError.localizedDescription);
+                }
+            }
+        }
+        
+        // Fallback: Use AVFoundation (older macOS or ScreenCaptureKit failure)
+        NSLog(@"📼 Falling back to AVFoundation - overlay windows may appear in recording");
+        
         // Create capture session
         g_captureSession = [[AVCaptureSession alloc] init];
         [g_captureSession beginConfiguration];
@@ -176,6 +217,9 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         // Set cursor capture
         g_screenInput.capturesCursor = captureCursor;
         
+        // Configure screen input options
+        g_screenInput.capturesMouseClicks = NO;
+        
         if ([g_captureSession canAddInput:g_screenInput]) {
             [g_captureSession addInput:g_screenInput];
         } else {
@@ -330,8 +374,17 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     }
     
     @try {
-        [g_movieFileOutput stopRecording];
-        [g_captureSession stopRunning];
+        if (g_movieFileOutput) {
+            [g_movieFileOutput stopRecording];
+        }
+        if (g_captureSession) {
+            [g_captureSession stopRunning];
+        }
+        
+        // Try to stop ScreenCaptureKit if it's being used
+        if (@available(macOS 12.3, *)) {
+            [ScreenCaptureKitRecorder stopRecording];
+        }
         
         g_isRecording = false;
         return Napi::Boolean::New(env, true);

package/src/screen_capture_kit.mm

@@ -0,0 +1,186 @@
+#import "screen_capture_kit.h"
+
+// Global state
+static SCStream *g_stream = nil;
+static id<SCStreamDelegate> g_streamDelegate = nil;
+static BOOL g_isRecording = NO;
+
+@interface ScreenCaptureKitRecorderDelegate : NSObject <SCStreamDelegate>
+@property (nonatomic, copy) void (^completionHandler)(NSURL *outputURL, NSError *error);
+@end
+
+@implementation ScreenCaptureKitRecorderDelegate
+- (void)stream:(SCStream *)stream didStopWithError:(NSError *)error {
+    NSLog(@"ScreenCaptureKit recording stopped with error: %@", error);
+}
+@end
+
+@implementation ScreenCaptureKitRecorder
+
++ (BOOL)isScreenCaptureKitAvailable {
+    if (@available(macOS 12.3, *)) {
+        return YES;
+    }
+    return NO;
+}
+
++ (BOOL)startRecordingWithConfiguration:(NSDictionary *)config 
+                               delegate:(id)delegate 
+                                  error:(NSError **)error {
+    
+    if (@available(macOS 12.3, *)) {
+        @try {
+            // Get current app PID to exclude overlay windows
+            NSRunningApplication *currentApp = [NSRunningApplication currentApplication];
+            pid_t currentPID = currentApp.processIdentifier;
+            
+            // Get all shareable content synchronously for immediate response
+            dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+            __block BOOL success = NO;
+            __block NSError *contentError = nil;
+            
+            [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *content, NSError *error) {
+                if (error) {
+                    NSLog(@"Failed to get shareable content: %@", error);
+                    contentError = error;
+                    dispatch_semaphore_signal(semaphore);
+                    return;
+                }
+                
+                // Find display to record
+                SCDisplay *targetDisplay = content.displays.firstObject; // Default to first display
+                if (config[@"displayId"]) {
+                    CGDirectDisplayID displayID = [config[@"displayId"] unsignedIntValue];
+                    for (SCDisplay *display in content.displays) {
+                        if (display.displayID == displayID) {
+                            targetDisplay = display;
+                            break;
+                        }
+                    }
+                }
+                
+                // Get current process and Electron app windows to exclude
+                NSMutableArray *excludedWindows = [NSMutableArray array];
+                NSMutableArray *excludedApps = [NSMutableArray array];
+                
+                // Exclude current Node.js process windows (overlay selectors)
+                for (SCWindow *window in content.windows) {
+                    if (window.owningApplication.processID == currentPID) {
+                        [excludedWindows addObject:window];
+                        NSLog(@"🚫 Excluding Node.js overlay window: %@ (PID: %d)", window.title, currentPID);
+                    }
+                }
+                
+                // Also try to exclude Electron app if running (common overlay use case)
+                for (SCWindow *window in content.windows) {
+                    NSString *appName = window.owningApplication.applicationName;
+                    if ([appName containsString:@"Electron"] || 
+                        [appName isEqualToString:@"electron"] ||
+                        [window.title containsString:@"Electron"]) {
+                        [excludedWindows addObject:window];
+                        NSLog(@"🚫 Excluding Electron window: %@ from %@", window.title, appName);
+                    }
+                }
+                
+                NSLog(@"📊 Total windows to exclude: %lu", (unsigned long)excludedWindows.count);
+                
+                // Create content filter - exclude overlay windows from recording
+                SCContentFilter *filter = [[SCContentFilter alloc] 
+                    initWithDisplay:targetDisplay 
+                    excludingWindows:excludedWindows];
+                NSLog(@"🎯 Using window-level exclusion for overlay prevention");
+                
+                // Create stream configuration
+                SCStreamConfiguration *streamConfig = [[SCStreamConfiguration alloc] init];
+                
+                // Handle capture area if specified
+                if (config[@"captureRect"]) {
+                    NSDictionary *rect = config[@"captureRect"];
+                    streamConfig.width = [rect[@"width"] integerValue];
+                    streamConfig.height = [rect[@"height"] integerValue];
+                    // Note: ScreenCaptureKit crop rect would need additional handling
+                } else {
+                    streamConfig.width = (NSInteger)targetDisplay.width;
+                    streamConfig.height = (NSInteger)targetDisplay.height;
+                }
+                
+                streamConfig.minimumFrameInterval = CMTimeMake(1, 60); // 60 FPS
+                streamConfig.queueDepth = 5;
+                streamConfig.showsCursor = [config[@"captureCursor"] boolValue];
+                streamConfig.capturesAudio = [config[@"includeSystemAudio"] boolValue];
+                
+                // Create delegate
+                g_streamDelegate = [[ScreenCaptureKitRecorderDelegate alloc] init];
+                
+                // Create and start stream
+                g_stream = [[SCStream alloc] initWithFilter:filter 
+                                              configuration:streamConfig 
+                                                   delegate:g_streamDelegate];
+                
+                [g_stream startCaptureWithCompletionHandler:^(NSError *streamError) {
+                    if (streamError) {
+                        NSLog(@"❌ Failed to start ScreenCaptureKit recording: %@", streamError);
+                        contentError = streamError;
+                        g_isRecording = NO;
+                    } else {
+                        NSLog(@"✅ ScreenCaptureKit recording started successfully (excluding %lu overlay windows)", (unsigned long)excludedWindows.count);
+                        g_isRecording = YES;
+                        success = YES;
+                    }
+                    dispatch_semaphore_signal(semaphore);
+                }];
+            }];
+            
+            // Wait for completion (with timeout)
+            dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC);
+            if (dispatch_semaphore_wait(semaphore, timeout) == 0) {
+                if (contentError && error) {
+                    *error = contentError;
+                }
+                return success;
+            } else {
+                NSLog(@"⏰ ScreenCaptureKit initialization timeout");
+                if (error) {
+                    *error = [NSError errorWithDomain:@"ScreenCaptureKitError" 
+                                                 code:-2 
+                                             userInfo:@{NSLocalizedDescriptionKey: @"Initialization timeout"}];
+                }
+                return NO;
+            }
+            
+        } @catch (NSException *exception) {
+            NSLog(@"ScreenCaptureKit recording exception: %@", exception);
+            if (error) {
+                *error = [NSError errorWithDomain:@"ScreenCaptureKitError" 
+                                             code:-1 
+                                         userInfo:@{NSLocalizedDescriptionKey: exception.reason}];
+            }
+            return NO;
+        }
+    }
+    
+    return NO;
+}
+
++ (void)stopRecording {
+    if (@available(macOS 12.3, *)) {
+        if (g_stream && g_isRecording) {
+            [g_stream stopCaptureWithCompletionHandler:^(NSError *error) {
+                if (error) {
+                    NSLog(@"Error stopping ScreenCaptureKit recording: %@", error);
+                } else {
+                    NSLog(@"ScreenCaptureKit recording stopped successfully");
+                }
+                g_isRecording = NO;
+                g_stream = nil;
+                g_streamDelegate = nil;
+            }];
+        }
+    }
+}
+
++ (BOOL)isRecording {
+    return g_isRecording;
+}
+
+@end

package/src/window_selector.mm

@@ -15,6 +15,23 @@ static NSButton *g_selectButton = nil;
 static NSTimer *g_trackingTimer = nil;
 static NSDictionary *g_selectedWindowInfo = nil;
 static NSMutableArray *g_allWindows = nil;
+
+// Functions to hide/show main overlay window during recording
+void hideAllOverlayWindows() {
+    if (g_overlayWindow && [g_overlayWindow isVisible]) {
+        [g_overlayWindow setAlphaValue:0.0];
+        [g_overlayWindow orderOut:nil];
+        NSLog(@"🫥 Hidden main overlay window for recording");
+    }
+}
+
+void showAllOverlayWindows() {
+    if (g_overlayWindow) {
+        [g_overlayWindow setAlphaValue:1.0];
+        [g_overlayWindow orderFront:nil];
+        NSLog(@"👁️ Restored main overlay window after recording");
+    }
+}
 static NSDictionary *g_currentWindowUnderCursor = nil;
 static bool g_bringToFrontEnabled = false; // Default disabled for overlay-only highlighting
 static bool g_hasToggledWindow = false; // Track if any window is currently toggled