node-mac-recorder 2.4.11 → 2.4.13

package/src/window_selector.mm

@@ -5,7 +5,6 @@
 #import <ApplicationServices/ApplicationServices.h>
 #import <Carbon/Carbon.h>
 #import <Accessibility/Accessibility.h>
-#import <ScreenCaptureKit/ScreenCaptureKit.h>
 
 // Global state for window selection
 static bool g_isWindowSelecting = false;
@@ -36,7 +35,6 @@ void cleanupWindowSelector();
 void updateOverlay();
 NSDictionary* getWindowUnderCursor(CGPoint point);
 NSArray* getAllSelectableWindows();
-NSArray* getAllSelectableWindowsLegacy();
 bool bringWindowToFront(int windowId);
 void cleanupRecordingPreview();
 bool showRecordingPreview(NSDictionary *windowInfo);
@@ -223,10 +221,8 @@ bool hideScreenRecordingPreview();
 @implementation WindowSelectorDelegate
 - (void)selectButtonClicked:(id)sender {
     if (g_currentWindowUnderCursor) {
-        g_selectedWindowInfo = [g_currentWindowUnderCursor copy];
-        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.05 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-            cleanupWindowSelector();
-        });
+        g_selectedWindowInfo = [g_currentWindowUnderCursor retain];
+        cleanupWindowSelector();
     }
 }
 
@@ -235,24 +231,25 @@ bool hideScreenRecordingPreview();
     NSInteger screenIndex = [button tag];
     
     // Get screen info from global array using button tag
-    if (g_allScreens && screenIndex >= 0 && screenIndex < (NSInteger)[g_allScreens count]) {
+    if (g_allScreens && screenIndex >= 0 && screenIndex < [g_allScreens count]) {
         NSDictionary *screenInfo = [g_allScreens objectAtIndex:screenIndex];
-        g_selectedScreenInfo = [screenInfo copy];
-        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.05 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-            cleanupScreenSelector();
-        });
+        g_selectedScreenInfo = [screenInfo retain];
+        
+        NSLog(@"🖥️ SCREEN BUTTON CLICKED: %@ (%@)", 
+              [screenInfo objectForKey:@"name"],
+              [screenInfo objectForKey:@"resolution"]);
+        
+        cleanupScreenSelector();
     }
 }
 
 - (void)cancelButtonClicked:(id)sender {
+    NSLog(@"🚫 CANCEL BUTTON CLICKED: Selection cancelled");
+    // Clean up without selecting anything
     if (g_isScreenSelecting) {
-        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.05 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-            cleanupScreenSelector();
-        });
+        cleanupScreenSelector();
     } else {
-        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.05 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-            cleanupWindowSelector();
-        });
+        cleanupWindowSelector();
     }
 }
 
@@ -369,83 +366,8 @@ bool bringWindowToFront(int windowId) {
     }
 }
 
-// Get all selectable windows using ScreenCaptureKit
+// Get all selectable windows
 NSArray* getAllSelectableWindows() {
-    @autoreleasepool {
-        NSMutableArray *windows = [NSMutableArray array];
-        
-        // Check if ScreenCaptureKit is available (requires macOS 12.3+)
-        if (@available(macOS 12.3, *)) {
-            // Use dispatch_semaphore for synchronous SCShareableContent retrieval
-            dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
-            __block SCShareableContent *content = nil;
-            __block NSError *error = nil;
-            
-            [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *shareableContent, NSError *contentError) {
-                content = shareableContent;
-                error = contentError;
-                dispatch_semaphore_signal(semaphore);
-            }];
-            
-            // Wait for completion (timeout after 5 seconds)
-            dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC);
-            if (dispatch_semaphore_wait(semaphore, timeout) == 0 && content) {
-                NSLog(@"✅ ScreenCaptureKit: Found %lu windows", (unsigned long)content.windows.count);
-                
-                for (SCWindow *scWindow in content.windows) {
-                    // Skip windows without proper frame or title
-                    if (scWindow.frame.size.width < 50 || scWindow.frame.size.height < 50) continue;
-                    if (!scWindow.owningApplication) continue;
-                    
-                    // Skip system applications
-                    NSString *bundleId = scWindow.owningApplication.bundleIdentifier;
-                    NSString *appName = scWindow.owningApplication.applicationName;
-                    if ([bundleId hasPrefix:@"com.apple.dock"] ||
-                        [bundleId hasPrefix:@"com.apple.WindowServer"] ||
-                        [bundleId hasPrefix:@"com.apple.controlcenter"] ||
-                        [bundleId hasPrefix:@"com.apple.notificationcenterui"]) {
-                        continue;
-                    }
-                    
-                    // Convert SCWindow coordinates to match CGWindow coordinate system
-                    CGRect frame = scWindow.frame;
-                    int x = (int)frame.origin.x;
-                    int y = (int)frame.origin.y;  
-                    int width = (int)frame.size.width;
-                    int height = (int)frame.size.height;
-                    
-                    NSString *windowTitle = scWindow.title ?: @"Untitled";
-                    if ([windowTitle length] == 0) windowTitle = @"Untitled";
-                    
-                    NSDictionary *window = @{
-                        @"id": @(scWindow.windowID),
-                        @"title": windowTitle,
-                        @"appName": appName ?: @"Unknown App",
-                        @"x": @(x),
-                        @"y": @(y),
-                        @"width": @(width),
-                        @"height": @(height),
-                        @"bundleId": bundleId ?: @""
-                    };
-                    
-                    [windows addObject:window];
-                }
-            } else {
-                NSLog(@"❌ ScreenCaptureKit: Failed to get shareable content or timeout occurred");
-                // Fall back to CGWindowList as backup
-                return getAllSelectableWindowsLegacy();
-            }
-        } else {
-            NSLog(@"⚠️ ScreenCaptureKit not available, falling back to CGWindowList");
-            return getAllSelectableWindowsLegacy();
-        }
-        
-        return [windows copy];
-    }
-}
-
-// Legacy window enumeration using CGWindowList (fallback for older macOS)
-NSArray* getAllSelectableWindowsLegacy() {
     @autoreleasepool {
         NSMutableArray *windows = [NSMutableArray array];
         
@@ -497,56 +419,22 @@ NSArray* getAllSelectableWindowsLegacy() {
     }
 }
 
-// Get window under cursor point using real-time mouse position
+// Get window under cursor point
 NSDictionary* getWindowUnderCursor(CGPoint point) {
     @autoreleasepool {
-        // Get window ID directly under cursor using macOS API
-        CFArrayRef windowList = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly, kCGNullWindowID);
-        
-        if (windowList) {
-            NSArray *windowArray = (__bridge NSArray *)windowList;
+        if (!g_allWindows) return nil;
+        
+        // Find window that contains the cursor point
+        for (NSDictionary *window in g_allWindows) {
+            int x = [[window objectForKey:@"x"] intValue];
+            int y = [[window objectForKey:@"y"] intValue];
+            int width = [[window objectForKey:@"width"] intValue];
+            int height = [[window objectForKey:@"height"] intValue];
             
-            // Find the topmost window at cursor position
-            for (NSDictionary *windowInfo in windowArray) {
-                NSDictionary *bounds = [windowInfo objectForKey:(NSString *)kCGWindowBounds];
-                NSNumber *layer = [windowInfo objectForKey:(NSString *)kCGWindowLayer];
-                NSString *owner = [windowInfo objectForKey:(NSString *)kCGWindowOwnerName];
-                NSNumber *winID = [windowInfo objectForKey:(NSString *)kCGWindowNumber];
-                
-                if (!bounds || !winID || !owner) continue;
-                if ([layer intValue] != 0) continue; // Only normal windows
-                if ([owner isEqualToString:@"WindowServer"] || [owner isEqualToString:@"Dock"]) continue;
-                
-                int x = [[bounds objectForKey:@"X"] intValue];
-                int y = [[bounds objectForKey:@"Y"] intValue];
-                int width = [[bounds objectForKey:@"Width"] intValue];
-                int height = [[bounds objectForKey:@"Height"] intValue];
-                
-                // Skip too small windows
-                if (width < 50 || height < 50) continue;
-                
-                // Check if cursor is within window bounds
-                if (point.x >= x && point.x <= x + width &&
-                    point.y >= y && point.y <= y + height) {
-                    
-                    NSString *windowName = [windowInfo objectForKey:(NSString *)kCGWindowName];
-                    
-                    // Create window info in our format
-                    NSDictionary *window = @{
-                        @"id": winID,
-                        @"title": windowName ?: @"Untitled",
-                        @"appName": owner,
-                        @"x": @(x),
-                        @"y": @(y),
-                        @"width": @(width),
-                        @"height": @(height)
-                    };
-                    
-                    CFRelease(windowList);
-                    return window;
-                }
+            if (point.x >= x && point.x <= x + width &&
+                point.y >= y && point.y <= y + height) {
+                return window;
             }
-            CFRelease(windowList);
         }
         
         return nil;
@@ -555,11 +443,6 @@ NSDictionary* getWindowUnderCursor(CGPoint point) {
 
 // Update overlay to highlight window under cursor
 void updateOverlay() {
-    // Ensure AppKit usage on main thread
-    if (![NSThread isMainThread]) {
-        dispatch_async(dispatch_get_main_queue(), ^{ updateOverlay(); });
-        return;
-    }
     @autoreleasepool {
         if (!g_isWindowSelecting || !g_overlayWindow) return;
         
@@ -575,7 +458,8 @@ void updateOverlay() {
         
         if (windowUnderCursor && ![windowUnderCursor isEqualToDictionary:g_currentWindowUnderCursor]) {
             // Update current window
-            g_currentWindowUnderCursor = windowUnderCursor;
+            [g_currentWindowUnderCursor release];
+            g_currentWindowUnderCursor = [windowUnderCursor retain];
             
             // Update overlay position and size
             int x = [[windowUnderCursor objectForKey:@"x"] intValue];
@@ -583,19 +467,36 @@ void updateOverlay() {
             int width = [[windowUnderCursor objectForKey:@"width"] intValue];
             int height = [[windowUnderCursor objectForKey:@"height"] intValue];
             
-            // Convert coordinates from CGWindow (top-left) to NSWindow (bottom-left)
-            NSScreen *mainScreen = [NSScreen mainScreen];
-            CGFloat screenHeight = [mainScreen frame].size.height;
-            CGFloat adjustedY = screenHeight - y - height;
+            // Find which screen contains the window center
+            NSArray *screens = [NSScreen screens];
+            NSScreen *windowScreen = nil;
+            CGFloat windowCenterX = x + width / 2;
+            CGFloat windowCenterY = y + height / 2;
             
-            // Clamp overlay to screen bounds to avoid partial off-screen issues
-            NSRect screenFrame = [mainScreen frame];
-            CGFloat clampedX = MAX(screenFrame.origin.x, MIN(x, screenFrame.origin.x + screenFrame.size.width - width));
-            CGFloat clampedY = MAX(screenFrame.origin.y, MIN(adjustedY, screenFrame.origin.y + screenFrame.size.height - height));
-            CGFloat clampedWidth = MIN(width, screenFrame.size.width - (clampedX - screenFrame.origin.x));
-            CGFloat clampedHeight = MIN(height, screenFrame.size.height - (clampedY - screenFrame.origin.y));
+            for (NSScreen *screen in screens) {
+                NSRect screenFrame = [screen frame];
+                // Convert screen frame to CGWindow coordinates
+                CGFloat screenTop = screenFrame.origin.y + screenFrame.size.height;
+                CGFloat screenBottom = screenFrame.origin.y;
+                CGFloat screenLeft = screenFrame.origin.x;
+                CGFloat screenRight = screenFrame.origin.x + screenFrame.size.width;
+                
+                if (windowCenterX >= screenLeft && windowCenterX <= screenRight &&
+                    windowCenterY >= screenBottom && windowCenterY <= screenTop) {
+                    windowScreen = screen;
+                    break;
+                }
+            }
             
-            NSRect overlayFrame = NSMakeRect(clampedX, clampedY, clampedWidth, clampedHeight);
+            // Use main screen if no specific screen found
+            if (!windowScreen) windowScreen = [NSScreen mainScreen];
+            
+            // Convert coordinates from CGWindow (top-left) to NSWindow (bottom-left) for the specific screen
+            CGFloat screenHeight = [windowScreen frame].size.height;
+            CGFloat adjustedY = screenHeight - y - height;
+            
+            // Use actual window coordinates without clamping to preserve overlay accuracy
+            NSRect overlayFrame = NSMakeRect(x, adjustedY, width, height);
             
             NSString *windowTitle = [windowUnderCursor objectForKey:@"title"] ?: @"Untitled";
             NSString *appName = [windowUnderCursor objectForKey:@"appName"] ?: @"Unknown";
@@ -617,6 +518,8 @@ void updateOverlay() {
                     }
                 }
             }
+            
+            // Ensure overlay is on the correct screen
             [g_overlayWindow setFrame:overlayFrame display:YES];
             
             // Update overlay view window info
@@ -666,6 +569,7 @@ void updateOverlay() {
             NSLog(@"🚪 WINDOW LEFT: %@ - \"%@\"", leftAppName, leftWindowTitle);
             
             [g_overlayWindow orderOut:nil];
+            [g_currentWindowUnderCursor release];
             g_currentWindowUnderCursor = nil;
         }
     }
@@ -673,12 +577,6 @@ void updateOverlay() {
 
 // Cleanup function
 void cleanupWindowSelector() {
-    if (![NSThread isMainThread]) {
-        dispatch_async(dispatch_get_main_queue(), ^{ cleanupWindowSelector(); });
-        return;
-    }
-    
-    NSLog(@"🧹 Cleaning up window selector resources");
     g_isWindowSelecting = false;
     
     // Stop tracking timer
@@ -703,25 +601,24 @@ void cleanupWindowSelector() {
     
     // Clean up delegate
     if (g_delegate) {
+        [g_delegate release];
         g_delegate = nil;
     }
     
     // Clean up data
     if (g_allWindows) {
+        [g_allWindows release];
         g_allWindows = nil;
     }
     
     if (g_currentWindowUnderCursor) {
+        [g_currentWindowUnderCursor release];
         g_currentWindowUnderCursor = nil;
     }
 }
 
 // Recording preview functions
 void cleanupRecordingPreview() {
-    if (![NSThread isMainThread]) {
-        dispatch_async(dispatch_get_main_queue(), ^{ cleanupRecordingPreview(); });
-        return;
-    }
     if (g_recordingPreviewWindow) {
         [g_recordingPreviewWindow close];
         g_recordingPreviewWindow = nil;
@@ -729,6 +626,7 @@ void cleanupRecordingPreview() {
     }
     
     if (g_recordingWindowInfo) {
+        [g_recordingWindowInfo release];
         g_recordingWindowInfo = nil;
     }
 }
@@ -741,7 +639,7 @@ bool showRecordingPreview(NSDictionary *windowInfo) {
         if (!windowInfo) return false;
         
         // Store window info
-        g_recordingWindowInfo = windowInfo;
+        g_recordingWindowInfo = [windowInfo retain];
         
         // Get main screen bounds for full screen overlay
         NSScreen *mainScreen = [NSScreen mainScreen];
@@ -801,10 +699,6 @@ bool hideRecordingPreview() {
 
 // Screen selection functions
 void cleanupScreenSelector() {
-    if (![NSThread isMainThread]) {
-        dispatch_async(dispatch_get_main_queue(), ^{ cleanupScreenSelector(); });
-        return;
-    }
     g_isScreenSelecting = false;
     
     // Remove key event monitor
@@ -818,11 +712,13 @@ void cleanupScreenSelector() {
         for (NSWindow *overlayWindow in g_screenOverlayWindows) {
             [overlayWindow close];
         }
+        [g_screenOverlayWindows release];
         g_screenOverlayWindows = nil;
     }
     
     // Clean up screen data
     if (g_allScreens) {
+        [g_allScreens release];
         g_allScreens = nil;
     }
 }
@@ -830,13 +726,7 @@ void cleanupScreenSelector() {
 bool startScreenSelection() {
     @try {
         if (g_isScreenSelecting) return false;
-        // Force to main thread
-        if (![NSThread isMainThread]) {
-            __block BOOL ok = NO;
-            dispatch_sync(dispatch_get_main_queue(), ^{ ok = startScreenSelection(); });
-            return ok;
-        }
-
+        
         // Get all available screens
         NSArray *screens = [NSScreen screens];
         if (!screens || [screens count] == 0) return false;
@@ -845,7 +735,7 @@ bool startScreenSelection() {
         NSMutableArray *screenInfoArray = [[NSMutableArray alloc] init];
         g_screenOverlayWindows = [[NSMutableArray alloc] init];
         
-        for (NSUInteger i = 0; i < [screens count]; i++) {
+        for (NSInteger i = 0; i < [screens count]; i++) {
             NSScreen *screen = [screens objectAtIndex:i];
             NSRect screenFrame = [screen frame];
             
@@ -886,16 +776,15 @@ bool startScreenSelection() {
             NSButton *selectButton = [[NSButton alloc] initWithFrame:NSMakeRect(0, 0, 180, 60)];
             [selectButton setTitle:@"Start Record"];
             [selectButton setButtonType:NSButtonTypeMomentaryPushIn];
-            [selectButton setBezelStyle:NSBezelStyleRounded];
+            [selectButton setBezelStyle:NSBezelStyleRegularSquare];
             [selectButton setFont:[NSFont systemFontOfSize:16 weight:NSFontWeightSemibold]];
             [selectButton setTag:i]; // Set screen index as tag
             
             // Blue background with white text
             [selectButton setWantsLayer:YES];
-            [selectButton.layer setBackgroundColor:[[NSColor colorWithRed:0.0 green:0.4 blue:0.8 alpha:0.9] CGColor]];
-            [selectButton.layer setCornerRadius:8.0];
-            [selectButton.layer setBorderColor:[[NSColor colorWithRed:0.0 green:0.3 blue:0.7 alpha:1.0] CGColor]];
-            [selectButton.layer setBorderWidth:2.0];
+            [selectButton.layer setBackgroundColor:[[NSColor colorWithRed:0.2 green:0.6 blue:1.0 alpha:0.95] CGColor]];
+            [selectButton.layer setCornerRadius:12.0];
+            [selectButton.layer setBorderWidth:0.0];
             
             // White text color
             NSMutableAttributedString *titleString = [[NSMutableAttributedString alloc] 
@@ -922,15 +811,14 @@ bool startScreenSelection() {
             NSButton *screenCancelButton = [[NSButton alloc] initWithFrame:NSMakeRect(0, 0, 120, 40)];
             [screenCancelButton setTitle:@"Cancel"];
             [screenCancelButton setButtonType:NSButtonTypeMomentaryPushIn];
-            [screenCancelButton setBezelStyle:NSBezelStyleRounded];
+            [screenCancelButton setBezelStyle:NSBezelStyleRegularSquare];
             [screenCancelButton setFont:[NSFont systemFontOfSize:14 weight:NSFontWeightMedium]];
             
             // Gray cancel button styling
             [screenCancelButton setWantsLayer:YES];
-            [screenCancelButton.layer setBackgroundColor:[[NSColor colorWithRed:0.5 green:0.5 blue:0.5 alpha:0.8] CGColor]];
-            [screenCancelButton.layer setCornerRadius:6.0];
-            [screenCancelButton.layer setBorderColor:[[NSColor colorWithRed:0.4 green:0.4 blue:0.4 alpha:1.0] CGColor]];
-            [screenCancelButton.layer setBorderWidth:1.0];
+            [screenCancelButton.layer setBackgroundColor:[[NSColor colorWithRed:0.3 green:0.3 blue:0.3 alpha:0.9] CGColor]];
+            [screenCancelButton.layer setCornerRadius:10.0];
+            [screenCancelButton.layer setBorderWidth:0.0];
             
             // White text for cancel button
             NSMutableAttributedString *screenCancelTitleString = [[NSMutableAttributedString alloc] 
@@ -968,11 +856,11 @@ bool startScreenSelection() {
             [overlayWindow makeKeyAndOrderFront:nil];
             
             [g_screenOverlayWindows addObject:overlayWindow];
-            screenInfo = nil;
+            [screenInfo release];
         }
         
-        g_allScreens = screenInfoArray;
-        screenInfoArray = nil;
+        g_allScreens = [screenInfoArray retain];
+        [screenInfoArray release];
         g_isScreenSelecting = true;
         
         // Add ESC key event monitor to cancel selection
@@ -998,12 +886,9 @@ bool startScreenSelection() {
 bool stopScreenSelection() {
     @try {
         if (!g_isScreenSelecting) return false;
-        if (![NSThread isMainThread]) {
-            __block BOOL ok = NO;
-            dispatch_sync(dispatch_get_main_queue(), ^{ ok = stopScreenSelection(); });
-            return ok;
-        }
+        
         cleanupScreenSelector();
+        NSLog(@"🖥️ SCREEN SELECTION: Stopped");
         return true;
         
     } @catch (NSException *exception) {
@@ -1015,10 +900,11 @@ bool stopScreenSelection() {
 NSDictionary* getSelectedScreenInfo() {
     if (!g_selectedScreenInfo) return nil;
     
-    NSDictionary *result = g_selectedScreenInfo;
+    NSDictionary *result = [g_selectedScreenInfo retain];
+    [g_selectedScreenInfo release];
     g_selectedScreenInfo = nil;
     
-    return result;
+    return [result autorelease];
 }
 
 bool showScreenRecordingPreview(NSDictionary *screenInfo) {
@@ -1033,10 +919,10 @@ bool showScreenRecordingPreview(NSDictionary *screenInfo) {
         NSArray *screens = [NSScreen screens];
         if (!screens || [screens count] == 0) return false;
         
-        NSUInteger selectedScreenId = (NSUInteger)[[screenInfo objectForKey:@"id"] intValue];
+        int selectedScreenId = [[screenInfo objectForKey:@"id"] intValue];
         
         // Create overlay for each screen except the selected one
-        for (NSUInteger i = 0; i < [screens count]; i++) {
+        for (NSInteger i = 0; i < [screens count]; i++) {
             if (i == selectedScreenId) continue; // Skip selected screen
             
             NSScreen *screen = [screens objectAtIndex:i];
@@ -1067,7 +953,7 @@ bool showScreenRecordingPreview(NSDictionary *screenInfo) {
             }
         }
         
-        NSLog(@"🎬 SCREEN RECORDING PREVIEW: Showing overlay for Screen %lu", (unsigned long)selectedScreenId);
+        NSLog(@"🎬 SCREEN RECORDING PREVIEW: Showing overlay for Screen %d", selectedScreenId);
         
         return true;
         
@@ -1085,50 +971,14 @@ bool hideScreenRecordingPreview() {
 Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
-    // Electron safety check - prevent NSWindow crashes
-    const char* electronVersion = getenv("ELECTRON_VERSION");
-    const char* electronRunAs = getenv("ELECTRON_RUN_AS_NODE");
-    
-    NSLog(@"🔍 Debug: electronVersion='%s', electronRunAs='%s'", 
-          electronVersion ? electronVersion : "null", 
-          electronRunAs ? electronRunAs : "null");
-    
-    if (electronVersion || electronRunAs) {
-        NSLog(@"🔍 Detected Electron environment - using safe mode");
-        
-        // In Electron, return window list without creating native NSWindow overlays
-        // The Electron app can handle UI selection itself
-        @try {
-            NSArray *windows = getAllSelectableWindows();
-            
-            if (!windows || [windows count] == 0) {
-                NSLog(@"❌ No selectable windows found");
-                return Napi::Boolean::New(env, false);
-            }
-            
-            // Store windows for later retrieval via getWindowSelectionStatus
-            g_allWindows = [getAllSelectableWindows() mutableCopy];
-            g_isWindowSelecting = true;
-            
-            // Return true to indicate windows are available
-            // Electron app should call getWindowSelectionStatus to get the list
-            NSLog(@"✅ Electron-safe mode: %lu windows available for selection", (unsigned long)[windows count]);
-            return Napi::Boolean::New(env, true);
-            
-        } @catch (NSException *exception) {
-            NSLog(@"❌ Exception in Electron-safe window selection: %@", [exception reason]);
-            return Napi::Boolean::New(env, false);
-        }
-    }
-    
     if (g_isWindowSelecting) {
-        NSLog(@"⚠️ Window selection already in progress");
-        return Napi::Boolean::New(env, false);
+        Napi::TypeError::New(env, "Window selection already in progress").ThrowAsJavaScriptException();
+        return env.Null();
     }
     
     @try {
         // Get all windows
-        g_allWindows = [getAllSelectableWindows() mutableCopy];
+        g_allWindows = [getAllSelectableWindows() retain];
         
         if (!g_allWindows || [g_allWindows count] == 0) {
             Napi::Error::New(env, "No selectable windows found").ThrowAsJavaScriptException();
@@ -1159,15 +1009,14 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
         g_selectButton = [[NSButton alloc] initWithFrame:NSMakeRect(0, 0, 160, 60)];
         [g_selectButton setTitle:@"Start Record"];
         [g_selectButton setButtonType:NSButtonTypeMomentaryPushIn];
-        [g_selectButton setBezelStyle:NSBezelStyleRounded];
+        [g_selectButton setBezelStyle:NSBezelStyleRegularSquare];
         [g_selectButton setFont:[NSFont systemFontOfSize:16 weight:NSFontWeightSemibold]];
         
         // Blue background with white text
         [g_selectButton setWantsLayer:YES];
-        [g_selectButton.layer setBackgroundColor:[[NSColor colorWithRed:0.0 green:0.4 blue:0.8 alpha:0.9] CGColor]];
-        [g_selectButton.layer setCornerRadius:8.0];
-        [g_selectButton.layer setBorderColor:[[NSColor colorWithRed:0.0 green:0.3 blue:0.7 alpha:1.0] CGColor]];
-        [g_selectButton.layer setBorderWidth:2.0];
+        [g_selectButton.layer setBackgroundColor:[[NSColor colorWithRed:0.2 green:0.6 blue:1.0 alpha:0.95] CGColor]];
+        [g_selectButton.layer setCornerRadius:12.0];
+        [g_selectButton.layer setBorderWidth:0.0];
         
         // White text color
         NSMutableAttributedString *titleString = [[NSMutableAttributedString alloc] 
@@ -1195,15 +1044,14 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
         NSButton *cancelButton = [[NSButton alloc] initWithFrame:NSMakeRect(0, 0, 120, 40)];
         [cancelButton setTitle:@"Cancel"];
         [cancelButton setButtonType:NSButtonTypeMomentaryPushIn];
-        [cancelButton setBezelStyle:NSBezelStyleRounded];
+        [cancelButton setBezelStyle:NSBezelStyleRegularSquare];
         [cancelButton setFont:[NSFont systemFontOfSize:14 weight:NSFontWeightMedium]];
         
         // Gray cancel button styling
         [cancelButton setWantsLayer:YES];
-        [cancelButton.layer setBackgroundColor:[[NSColor colorWithRed:0.5 green:0.5 blue:0.5 alpha:0.8] CGColor]];
-        [cancelButton.layer setCornerRadius:6.0];
-        [cancelButton.layer setBorderColor:[[NSColor colorWithRed:0.4 green:0.4 blue:0.4 alpha:1.0] CGColor]];
-        [cancelButton.layer setBorderWidth:1.0];
+        [cancelButton.layer setBackgroundColor:[[NSColor colorWithRed:0.3 green:0.3 blue:0.3 alpha:0.9] CGColor]];
+        [cancelButton.layer setCornerRadius:10.0];
+        [cancelButton.layer setBorderWidth:0.0];
         
         // White text for cancel button
         NSMutableAttributedString *cancelTitleString = [[NSMutableAttributedString alloc] 
@@ -1308,54 +1156,26 @@ Napi::Value GetSelectedWindowInfo(const Napi::CallbackInfo& info) {
         NSLog(@"   📊 Details: ID=%@, Pos=(%d,%d), Size=%dx%d", 
               [g_selectedWindowInfo objectForKey:@"id"], x, y, width, height);
         
-        // Get all screens and find which screen contains this window
+        // Get all screens
         NSArray *screens = [NSScreen screens];
         NSScreen *windowScreen = nil;
         NSScreen *mainScreen = [NSScreen mainScreen];
         
-        // Calculate window center point for better screen detection
-        CGPoint windowCenter = CGPointMake(x + width/2, y + height/2);
-        
         for (NSScreen *screen in screens) {
             NSRect screenFrame = [screen frame];
             
-            // Check if window center is within screen bounds
-            if (windowCenter.x >= screenFrame.origin.x && 
-                windowCenter.x < screenFrame.origin.x + screenFrame.size.width &&
-                windowCenter.y >= screenFrame.origin.y && 
-                windowCenter.y < screenFrame.origin.y + screenFrame.size.height) {
+            // Convert window coordinates to screen-relative
+            if (x >= screenFrame.origin.x && 
+                x < screenFrame.origin.x + screenFrame.size.width &&
+                y >= screenFrame.origin.y && 
+                y < screenFrame.origin.y + screenFrame.size.height) {
                 windowScreen = screen;
-                NSLog(@"   🖥️ Window found on screen: (%.0f,%.0f) %.0fx%.0f", 
-                      screenFrame.origin.x, screenFrame.origin.y, 
-                      screenFrame.size.width, screenFrame.size.height);
                 break;
             }
         }
         
-        // If no exact match, find screen with maximum overlap
-        if (!windowScreen) {
-            CGFloat maxOverlapArea = 0;
-            NSRect windowRect = NSMakeRect(x, y, width, height);
-            
-            for (NSScreen *screen in screens) {
-                NSRect screenFrame = [screen frame];
-                NSRect intersection = NSIntersectionRect(windowRect, screenFrame);
-                CGFloat overlapArea = intersection.size.width * intersection.size.height;
-                
-                if (overlapArea > maxOverlapArea) {
-                    maxOverlapArea = overlapArea;
-                    windowScreen = screen;
-                }
-            }
-            
-            if (windowScreen) {
-                NSLog(@"   🖥️ Window assigned to screen with max overlap: %.0f pixels²", maxOverlapArea);
-            }
-        }
-        
         if (!windowScreen) {
             windowScreen = mainScreen;
-            NSLog(@"   🖥️ Window defaulted to main screen");
         }
         
         // Add screen information
@@ -1368,6 +1188,7 @@ Napi::Value GetSelectedWindowInfo(const Napi::CallbackInfo& info) {
         result.Set("screenHeight", Napi::Number::New(env, (int)screenFrame.size.height));
         
         // Clear selected window info after reading
+        [g_selectedWindowInfo release];
         g_selectedWindowInfo = nil;
         
         return result;
@@ -1423,74 +1244,13 @@ Napi::Value GetWindowSelectionStatus(const Napi::CallbackInfo& info) {
         updateOverlay();
     }
     
-    // For Electron mode, also get real-time window under cursor
-    const char* electronVersion = getenv("ELECTRON_VERSION");
-    const char* electronRunAs = getenv("ELECTRON_RUN_AS_NODE");
-    
     Napi::Object result = Napi::Object::New(env);
     result.Set("isSelecting", Napi::Boolean::New(env, g_isWindowSelecting));
     result.Set("hasSelectedWindow", Napi::Boolean::New(env, g_selectedWindowInfo != nil));
     result.Set("windowCount", Napi::Number::New(env, g_allWindows ? [g_allWindows count] : 0));
     result.Set("hasOverlay", Napi::Boolean::New(env, g_overlayWindow != nil));
     
-    if (electronVersion || electronRunAs) {
-        // In Electron mode, get real-time window under cursor
-        @try {
-            NSPoint mouseLocation = [NSEvent mouseLocation];
-            NSScreen *mainScreen = [NSScreen mainScreen];
-            CGFloat screenHeight = [mainScreen frame].size.height;
-            CGPoint globalPoint = CGPointMake(mouseLocation.x, screenHeight - mouseLocation.y);
-            
-            NSDictionary *windowUnderCursor = getWindowUnderCursor(globalPoint);
-            
-            if (windowUnderCursor) {
-                Napi::Object currentWindow = Napi::Object::New(env);
-                currentWindow.Set("id", Napi::Number::New(env, [[windowUnderCursor objectForKey:@"id"] intValue]));
-                currentWindow.Set("title", Napi::String::New(env, [[windowUnderCursor objectForKey:@"title"] UTF8String]));
-                currentWindow.Set("appName", Napi::String::New(env, [[windowUnderCursor objectForKey:@"appName"] UTF8String]));
-                currentWindow.Set("x", Napi::Number::New(env, [[windowUnderCursor objectForKey:@"x"] intValue]));
-                currentWindow.Set("y", Napi::Number::New(env, [[windowUnderCursor objectForKey:@"y"] intValue]));
-                currentWindow.Set("width", Napi::Number::New(env, [[windowUnderCursor objectForKey:@"width"] intValue]));
-                currentWindow.Set("height", Napi::Number::New(env, [[windowUnderCursor objectForKey:@"height"] intValue]));
-                
-                // Add screen detection for Electron
-                int x = [[windowUnderCursor objectForKey:@"x"] intValue];
-                int y = [[windowUnderCursor objectForKey:@"y"] intValue];
-                int width = [[windowUnderCursor objectForKey:@"width"] intValue];
-                int height = [[windowUnderCursor objectForKey:@"height"] intValue];
-                
-                NSArray *screens = [NSScreen screens];
-                NSScreen *windowScreen = nil;
-                CGPoint windowCenter = CGPointMake(x + width/2, y + height/2);
-                
-                for (NSScreen *screen in screens) {
-                    NSRect screenFrame = [screen frame];
-                    if (windowCenter.x >= screenFrame.origin.x && 
-                        windowCenter.x < screenFrame.origin.x + screenFrame.size.width &&
-                        windowCenter.y >= screenFrame.origin.y && 
-                        windowCenter.y < screenFrame.origin.y + screenFrame.size.height) {
-                        windowScreen = screen;
-                        break;
-                    }
-                }
-                
-                if (windowScreen) {
-                    NSRect screenFrame = [windowScreen frame];
-                    currentWindow.Set("screenId", Napi::Number::New(env, [[windowScreen deviceDescription] objectForKey:@"NSScreenNumber"] ? 
-                        [[[windowScreen deviceDescription] objectForKey:@"NSScreenNumber"] intValue] : 0));
-                    currentWindow.Set("screenX", Napi::Number::New(env, (int)screenFrame.origin.x));
-                    currentWindow.Set("screenY", Napi::Number::New(env, (int)screenFrame.origin.y));
-                    currentWindow.Set("screenWidth", Napi::Number::New(env, (int)screenFrame.size.width));
-                    currentWindow.Set("screenHeight", Napi::Number::New(env, (int)screenFrame.size.height));
-                }
-                
-                result.Set("currentWindow", currentWindow);
-            }
-        } @catch (NSException *exception) {
-            // Ignore mouse tracking errors in Electron mode
-        }
-    } else if (g_currentWindowUnderCursor) {
-        // Native mode
+    if (g_currentWindowUnderCursor) {
         Napi::Object currentWindow = Napi::Object::New(env);
         currentWindow.Set("id", Napi::Number::New(env, [[g_currentWindowUnderCursor objectForKey:@"id"] intValue]));
         currentWindow.Set("title", Napi::String::New(env, [[g_currentWindowUnderCursor objectForKey:@"title"] UTF8String]));
@@ -1510,13 +1270,13 @@ Napi::Value ShowRecordingPreview(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
     if (info.Length() < 1) {
-        NSLog(@"⚠️ Window info object required");
-        return Napi::Boolean::New(env, false);
+        Napi::TypeError::New(env, "Window info object required").ThrowAsJavaScriptException();
+        return env.Null();
     }
     
     if (!info[0].IsObject()) {
-        NSLog(@"⚠️ Window info must be an object");
-        return Napi::Boolean::New(env, false);
+        Napi::TypeError::New(env, "Window info must be an object").ThrowAsJavaScriptException();
+        return env.Null();
     }
     
     @try {
@@ -1548,7 +1308,7 @@ Napi::Value ShowRecordingPreview(const Napi::CallbackInfo& info) {
         }
         
         bool success = showRecordingPreview(windowInfo);
-        windowInfo = nil;
+        [windowInfo release];
         
         return Napi::Boolean::New(env, success);
         
@@ -1574,57 +1334,11 @@ Napi::Value HideRecordingPreview(const Napi::CallbackInfo& info) {
 Napi::Value StartScreenSelection(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
-    // Electron safety check - prevent NSWindow crashes
-    const char* electronVersion = getenv("ELECTRON_VERSION");
-    const char* electronRunAs = getenv("ELECTRON_RUN_AS_NODE");
-    
-    NSLog(@"🔍 Screen Debug: electronVersion='%s', electronRunAs='%s'", 
-          electronVersion ? electronVersion : "null", 
-          electronRunAs ? electronRunAs : "null");
-    
-    if (electronVersion || electronRunAs) {
-        NSLog(@"🔍 Detected Electron environment - using safe screen selection");
-        
-        // In Electron, return screen list without creating native NSWindow overlays
-        @try {
-            NSArray *screens = [NSScreen screens];
-            
-            if (!screens || [screens count] == 0) {
-                NSLog(@"❌ No screens available");
-                return Napi::Boolean::New(env, false);
-            }
-            
-            // Store screens and select first one automatically for Electron
-            g_allScreens = screens;
-            g_isScreenSelecting = true;
-            
-            NSScreen *mainScreen = [screens firstObject];
-            g_selectedScreenInfo = @{
-                @"id": @((int)[screens indexOfObject:mainScreen]),
-                @"width": @((int)mainScreen.frame.size.width),
-                @"height": @((int)mainScreen.frame.size.height),
-                @"x": @((int)mainScreen.frame.origin.x),
-                @"y": @((int)mainScreen.frame.origin.y)
-            };
-            
-            // Mark as complete so getSelectedScreenInfo returns the selection
-            g_isScreenSelecting = false;
-            
-            NSLog(@"✅ Electron-safe screen selection: %lu screens available", (unsigned long)[screens count]);
-            return Napi::Boolean::New(env, true);
-            
-        } @catch (NSException *exception) {
-            NSLog(@"❌ Exception in Electron-safe screen selection: %@", [exception reason]);
-            return Napi::Boolean::New(env, false);
-        }
-    }
-    
     @try {
         bool success = startScreenSelection();
         return Napi::Boolean::New(env, success);
         
     } @catch (NSException *exception) {
-        NSLog(@"❌ Screen selection error: %@", exception);
         return Napi::Boolean::New(env, false);
     }
 }
@@ -1716,7 +1430,7 @@ Napi::Value ShowScreenRecordingPreview(const Napi::CallbackInfo& info) {
         }
         
         bool success = showScreenRecordingPreview(screenInfo);
-        screenInfo = nil;
+        [screenInfo release];
         
         return Napi::Boolean::New(env, success);