node-mac-recorder 2.16.15 → 2.16.17

package/.claude/settings.local.json

@@ -1,7 +1,7 @@
 {
   "permissions": {
     "allow": [
-      "Bash(FORCE_AVFOUNDATION=1 node -e \"\nconsole.log(''🧪 Testing area recording with scaling...'');\nconst MacRecorder = require(''./index.js'');\nconst recorder = new MacRecorder();\n\nconst options = {\n  captureArea: {\n    x: 200,\n    y: 200, \n    width: 800,\n    height: 600\n  }\n};\n\nrecorder.startRecording(''/tmp/area-scaling-test.mov'', options)\n  .then(success => {\n    console.log(''Area recording:'', success ? ''✅ SUCCESS'' : ''❌ FAILED'');\n    if (success) {\n      setTimeout(() => {\n        recorder.stopRecording().then(() => {\n          console.log(''✅ Area scaling test complete'');\n          const fs = require(''fs'');\n          if (fs.existsSync(''/tmp/area-scaling-test.mov'')) {\n            const size = Math.round(fs.statSync(''/tmp/area-scaling-test.mov'').size/1024);\n            console.log(''📹 File size:'', size + ''KB'');\n          }\n        });\n      }, 2000);\n    }\n  })\n  .catch(console.error);\n\")"
+      "Bash(FORCE_AVFOUNDATION=1 node -e \"\nconsole.log(''🧪 Testing per-screen window selector overlay system...'');\nconst WindowSelector = require(''./window-selector.js'');\nconst selector = new WindowSelector();\n\n// Test permission check first\nselector.checkPermissions().then(perms => {\n  console.log(''Permissions:'', perms);\n  \n  // Start window selection to test per-screen overlays\n  return selector.startSelection();\n}).then(() => {\n  console.log(''✅ Window selection started - testing per-screen overlays'');\n  console.log(''➡️ Move cursor over windows on different displays to test overlay positioning'');\n  \n  // Auto-stop after 10 seconds for testing\n  setTimeout(() => {\n    selector.stopSelection().then(() => {\n      console.log(''✅ Window selection stopped - test complete'');\n    });\n  }, 10000);\n}).catch(console.error);\n\")"
     ],
     "deny": [],
     "ask": []

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -65,8 +65,17 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         CGFloat scaleY = physicalSize.height / logicalSize.height;
         CGFloat scaleFactor = MAX(scaleX, scaleY); // Use max to handle non-uniform scaling
         
-        // For AVFoundation, use logical size (what CGDisplayCreateImage actually captures)
-        CGSize recordingSize = captureRect.size.width > 0 ? captureRect.size : logicalSize;
+        // CRITICAL FIX: Use actual captured image dimensions, not logical size
+        // CGDisplayCreateImage may return higher resolution on Retina displays
+        CGImageRef testImage = CGDisplayCreateImage(displayID);
+        CGSize actualImageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
+        CGImageRelease(testImage);
+        
+        // For AVFoundation, use actual image size that CGDisplayCreateImage returns
+        CGSize recordingSize = captureRect.size.width > 0 ? captureRect.size : actualImageSize;
+        
+        NSLog(@"🎯 CRITICAL: Logical %.0fx%.0f → Actual image %.0fx%.0f", 
+              logicalSize.width, logicalSize.height, actualImageSize.width, actualImageSize.height);
         
         NSLog(@"🖥️ Display bounds (logical): %.0fx%.0f", logicalSize.width, logicalSize.height);
         NSLog(@"🖥️ Display pixels (physical): %.0fx%.0f", physicalSize.width, physicalSize.height);
@@ -147,13 +156,30 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         
         // Apply scaling to capture rect if provided (for macOS 14/13 compatibility)
         if (!CGRectIsEmpty(captureRect)) {
-            // Note: captureRect comes in logical coordinates, keep as-is for CGDisplayCreateImage
-            g_avCaptureRect = captureRect;
-            NSLog(@"🔲 Capture area (logical): %.0f,%.0f %.0fx%.0f", 
-                  captureRect.origin.x, captureRect.origin.y, captureRect.size.width, captureRect.size.height);
+            // Scale capture rect to match actual image dimensions if needed
+            CGFloat imageScaleX = actualImageSize.width / logicalSize.width;
+            CGFloat imageScaleY = actualImageSize.height / logicalSize.height;
+            
+            if (imageScaleX > 1.1 || imageScaleY > 1.1) {
+                // Scale up capture rect for high-DPI displays
+                CGRect scaledRect = CGRectMake(
+                    captureRect.origin.x * imageScaleX,
+                    captureRect.origin.y * imageScaleY,
+                    captureRect.size.width * imageScaleX,
+                    captureRect.size.height * imageScaleY
+                );
+                g_avCaptureRect = scaledRect;
+                NSLog(@"🔲 Capture area scaled: %.0f,%.0f %.0fx%.0f (scale %.1fx%.1fx)", 
+                      scaledRect.origin.x, scaledRect.origin.y, scaledRect.size.width, scaledRect.size.height,
+                      imageScaleX, imageScaleY);
+            } else {
+                g_avCaptureRect = captureRect;
+                NSLog(@"🔲 Capture area (no scaling): %.0f,%.0f %.0fx%.0f", 
+                      captureRect.origin.x, captureRect.origin.y, captureRect.size.width, captureRect.size.height);
+            }
         } else {
             g_avCaptureRect = CGRectZero; // Full screen
-            NSLog(@"🖥️ Full screen capture (logical bounds)");
+            NSLog(@"🖥️ Full screen capture (actual image dimensions)");
         }
         
         g_avFrameNumber = 0;
@@ -214,8 +240,11 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                         size_t imageWidth = CGImageGetWidth(screenImage);
                         size_t imageHeight = CGImageGetHeight(screenImage);
                         
+                        NSLog(@"🔍 Debug: Buffer %zux%zu, Image %zux%zu", bufferWidth, bufferHeight, imageWidth, imageHeight);
+                        
                         if (bufferWidth != imageWidth || bufferHeight != imageHeight) {
-                            NSLog(@"⚠️ Size mismatch! Buffer %zux%zu vs Image %zux%zu", bufferWidth, bufferHeight, imageWidth, imageHeight);
+                            NSLog(@"⚠️ CRITICAL SIZE MISMATCH! Buffer %zux%zu vs Image %zux%zu", bufferWidth, bufferHeight, imageWidth, imageHeight);
+                            NSLog(@"   This indicates Retina scaling issue on macOS 14/13");
                         }
                         
                         CVPixelBufferLockBaseAddress(pixelBuffer, 0);

package/src/window_selector.mm

@@ -16,6 +16,11 @@ static NSTimer *g_trackingTimer = nil;
 static NSDictionary *g_selectedWindowInfo = nil;
 static NSMutableArray *g_allWindows = nil;
 
+// Per-screen overlay system
+static NSMutableArray *g_perScreenOverlays = nil;
+static NSMutableArray *g_perScreenOverlayViews = nil;
+static NSInteger g_activeScreenIndex = -1;
+
 // Functions to hide/show main overlay window during recording
 void hideAllOverlayWindows() {
     if (g_overlayWindow && [g_overlayWindow isVisible]) {
@@ -866,44 +871,58 @@ void updateOverlay() {
                 }
             }
             
-            // Convert global window coordinates to local view coordinates
-            // Account for multi-display offset from global origin
-            WindowSelectorOverlayView *overlayView = (WindowSelectorOverlayView *)g_overlayView;
-            NSPoint globalOffset = NSZeroPoint;
-            if (overlayView.globalOriginOffset) {
-                globalOffset = [overlayView.globalOriginOffset pointValue];
-            }
-            
-            // Determine if this is a primary display window
+            // NEW PER-SCREEN SYSTEM: Find which screen this window belongs to
             NSArray *allScreens = [NSScreen screens];
-            NSScreen *primaryScreen = [allScreens objectAtIndex:0]; // Primary screen
-            NSRect primaryFrame = [primaryScreen frame];
-            BOOL isPrimaryDisplayWindow = (x >= primaryFrame.origin.x && 
-                                         x <= primaryFrame.origin.x + primaryFrame.size.width &&
-                                         y >= primaryFrame.origin.y &&
-                                         y <= primaryFrame.origin.y + primaryFrame.size.height);
-            
-            CGFloat localX, localY;
-            if (isPrimaryDisplayWindow) {
-                // Primary display windows: Calculate dynamic offset from combined frame
-                NSRect combinedFrame = [g_overlayWindow frame];
-                
-                // Calculate primary screen offset within combined frame
-                CGFloat primaryOffsetX = primaryFrame.origin.x - combinedFrame.origin.x;
-                CGFloat primaryOffsetY = primaryFrame.origin.y - combinedFrame.origin.y;
+            NSInteger targetScreenIndex = -1;
+            NSScreen *targetScreen = nil;
+            
+            // Find screen containing this window
+            for (NSInteger i = 0; i < [allScreens count]; i++) {
+                NSScreen *screen = [allScreens objectAtIndex:i];
+                NSRect screenFrame = [screen frame];
                 
-                localX = x + primaryOffsetX;
-                localY = ([g_overlayView frame].size.height - (y + primaryOffsetY)) - height;
+                // Check if window center is within this screen bounds
+                CGFloat windowCenterX = x + width/2;
+                CGFloat windowCenterY = y + height/2;
                 
-            } else {
-                // Secondary display windows: Apply standard coordinate transformation
-                localX = x - globalOffset.x;
-                localY = ([g_overlayView frame].size.height - (y - globalOffset.y)) - height;
+                if (windowCenterX >= screenFrame.origin.x && 
+                    windowCenterX <= screenFrame.origin.x + screenFrame.size.width &&
+                    windowCenterY >= screenFrame.origin.y && 
+                    windowCenterY <= screenFrame.origin.y + screenFrame.size.height) {
+                    targetScreenIndex = i;
+                    targetScreen = screen;
+                    break;
+                }
+            }
+            
+            if (targetScreenIndex == -1) {
+                NSLog(@"⚠️ Window not found on any screen: (%.0f,%.0f)", (CGFloat)x, (CGFloat)y);
+                return;
             }
             
-            // Update overlay view window info for highlighting
-            [overlayView setWindowInfo:targetWindow];
-            [overlayView setHighlightFrame:NSMakeRect(localX, localY, width, height)];
+            // Get the overlay for target screen
+            NSWindow *targetOverlay = [g_perScreenOverlays objectAtIndex:targetScreenIndex];
+            WindowSelectorOverlayView *targetOverlayView = [g_perScreenOverlayViews objectAtIndex:targetScreenIndex];
+            NSRect targetScreenFrame = [targetScreen frame];
+            
+            // Calculate LOCAL coordinates within target screen (much simpler!)
+            CGFloat localX = x - targetScreenFrame.origin.x;
+            CGFloat localY = (targetScreenFrame.size.height - (y - targetScreenFrame.origin.y)) - height;
+            
+            NSLog(@"🎯 Window on Screen %ld: Global(%.0f,%.0f) → Local(%.0f,%.0f)", 
+                  targetScreenIndex, (CGFloat)x, (CGFloat)y, localX, localY);
+            
+            // Update active screen if changed
+            if (g_activeScreenIndex != targetScreenIndex) {
+                NSLog(@"🔄 Switching to Screen %ld overlay", targetScreenIndex);
+                g_activeScreenIndex = targetScreenIndex;
+                g_overlayWindow = targetOverlay;
+                g_overlayView = targetOverlayView;
+            }
+            
+            // Update TARGET overlay view window info for highlighting
+            [targetOverlayView setWindowInfo:targetWindow];
+            [targetOverlayView setHighlightFrame:NSMakeRect(localX, localY, width, height)];
             
             // Only reset toggle state when switching to different window (not for position updates)
             if (!g_hasToggledWindow) {
@@ -1123,7 +1142,27 @@ void cleanupWindowSelector() {
         g_windowKeyEventMonitor = nil;
     }
     
-    // Close overlay window
+    // NEW PER-SCREEN CLEANUP: Close all per-screen overlays
+    if (g_perScreenOverlays) {
+        NSLog(@"🧹 Cleaning up %lu per-screen overlays", [g_perScreenOverlays count]);
+        for (NSWindow *overlay in g_perScreenOverlays) {
+            if (overlay) {
+                [overlay close];
+            }
+        }
+        [g_perScreenOverlays release];
+        g_perScreenOverlays = nil;
+    }
+    
+    if (g_perScreenOverlayViews) {
+        [g_perScreenOverlayViews release];
+        g_perScreenOverlayViews = nil;
+    }
+    
+    // Reset per-screen state
+    g_activeScreenIndex = -1;
+    
+    // Close legacy overlay window (fallback cleanup)
     if (g_overlayWindow) {
         [g_overlayWindow close];
         g_overlayWindow = nil;
@@ -1836,32 +1875,55 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
         }
         
         // Get all windows
-        g_allWindows = [getAllSelectableWindows() retain];
+        g_allWindows = [[NSMutableArray alloc] initWithArray:getAllSelectableWindows()];
         
         if (!g_allWindows || [g_allWindows count] == 0) {
             Napi::Error::New(env, "No selectable windows found").ThrowAsJavaScriptException();
             return env.Null();
         }
         
-        // Create multi-display overlay window to prevent window dragging
+        // Create PER-SCREEN overlay windows (much simpler than combined overlay)
         NSArray *allScreens = [NSScreen screens];
-        NSRect combinedFrame = NSZeroRect;
+        g_perScreenOverlays = [[NSMutableArray alloc] init];
+        g_perScreenOverlayViews = [[NSMutableArray alloc] init];
+        
+        NSLog(@"🖥️ Creating per-screen overlays for %lu displays", [allScreens count]);
         
-        // Calculate combined frame that covers all displays
-        for (NSScreen *screen in allScreens) {
+        // Create overlay for each screen
+        for (NSInteger i = 0; i < [allScreens count]; i++) {
+            NSScreen *screen = [allScreens objectAtIndex:i];
             NSRect screenFrame = [screen frame];
-            if (NSEqualRects(combinedFrame, NSZeroRect)) {
-                combinedFrame = screenFrame;
-            } else {
-                combinedFrame = NSUnionRect(combinedFrame, screenFrame);
-            }
+            
+            // Create per-screen overlay window
+            NSWindow *screenOverlay = [[NoFocusWindow alloc] initWithContentRect:screenFrame
+                                                                        styleMask:NSWindowStyleMaskBorderless
+                                                                          backing:NSBackingStoreBuffered
+                                                                            defer:NO
+                                                                           screen:screen];
+            
+            // Create per-screen overlay view
+            WindowSelectorOverlayView *overlayView = [[WindowSelectorOverlayView alloc] initWithFrame:NSMakeRect(0, 0, screenFrame.size.width, screenFrame.size.height)];
+            [screenOverlay setContentView:overlayView];
+            
+            // Configure overlay window
+            [screenOverlay setStyleMask:NSWindowStyleMaskBorderless];
+            [screenOverlay setBackgroundColor:[NSColor clearColor]];
+            [screenOverlay setOpaque:NO];
+            [screenOverlay setIgnoresMouseEvents:NO];
+            [screenOverlay setAcceptsMouseMovedEvents:YES];
+            [screenOverlay setLevel:NSScreenSaverWindowLevel];
+            [screenOverlay setCollectionBehavior:NSWindowCollectionBehaviorCanJoinAllSpaces | NSWindowCollectionBehaviorStationary];
+            
+            NSLog(@"   Screen %ld: (%.0f,%.0f) %.0fx%.0f → Overlay created", i, screenFrame.origin.x, screenFrame.origin.y, screenFrame.size.width, screenFrame.size.height);
+            
+            [g_perScreenOverlays addObject:screenOverlay];
+            [g_perScreenOverlayViews addObject:overlayView];
         }
         
-        NSRect fullScreenFrame = combinedFrame;
-        g_overlayWindow = [[NoFocusWindow alloc] initWithContentRect:fullScreenFrame
-                                                           styleMask:NSWindowStyleMaskBorderless
-                                                             backing:NSBackingStoreBuffered
-                                                               defer:NO];
+        // For compatibility, keep first screen as main overlay
+        g_overlayWindow = [g_perScreenOverlays objectAtIndex:0];
+        g_overlayView = [g_perScreenOverlayViews objectAtIndex:0];
+        g_activeScreenIndex = 0;
         
         // Force completely borderless appearance
         [g_overlayWindow setStyleMask:NSWindowStyleMaskBorderless];
@@ -1886,17 +1948,7 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
         [g_overlayWindow setOpaque:NO];
         [g_overlayWindow setBackgroundColor:[NSColor clearColor]];
         
-        // Create overlay view covering all displays
-        // Convert global coordinates to local view coordinates (offset by origin)
-        NSRect localViewFrame = NSMakeRect(0, 0, fullScreenFrame.size.width, fullScreenFrame.size.height);
-        g_overlayView = [[WindowSelectorOverlayView alloc] initWithFrame:localViewFrame];
-        
-        // Store the global origin offset for coordinate conversion
-        WindowSelectorOverlayView *overlayView = (WindowSelectorOverlayView *)g_overlayView;
-        overlayView.globalOriginOffset = [NSValue valueWithPoint:fullScreenFrame.origin];
-        
-        NSLog(@"🔧 SET GlobalOriginOffset: (%.0f, %.0f)", fullScreenFrame.origin.x, fullScreenFrame.origin.y);
-        [g_overlayWindow setContentView:g_overlayView];
+        NSLog(@"✅ Per-screen overlay system initialized with %lu screens", [allScreens count]);
         
         // Note: NSWindow doesn't have setWantsLayer method, only NSView does