node-mac-recorder 2.15.8 → 2.15.10

package/debug-coordinates.js

@@ -0,0 +1,69 @@
+const MacRecorder = require('./index');
+
+async function debugCoordinates() {
+    const recorder = new MacRecorder();
+    const displays = await recorder.getDisplays();
+    
+    console.log('🖥️ Display coordinates analysis:');
+    displays.forEach((display, index) => {
+        console.log(`Display ${index}: ${display.name}`);
+        console.log(`  ID: ${display.id}`);
+        console.log(`  Position: (${display.x}, ${display.y})`);
+        console.log(`  Size: ${display.width}x${display.height}`);
+        console.log(`  isPrimary: ${display.isPrimary}`);
+        console.log('');
+    });
+    
+    // Calculate combined frame like we do in native code
+    let combinedFrame = { x: 0, y: 0, width: 0, height: 0 };
+    let first = true;
+    
+    for (const display of displays) {
+        if (first) {
+            combinedFrame = {
+                x: display.x,
+                y: display.y, 
+                width: display.width,
+                height: display.height
+            };
+            first = false;
+        } else {
+            const minX = Math.min(combinedFrame.x, display.x);
+            const minY = Math.min(combinedFrame.y, display.y);
+            const maxX = Math.max(combinedFrame.x + combinedFrame.width, display.x + display.width);
+            const maxY = Math.max(combinedFrame.y + combinedFrame.height, display.y + display.height);
+            
+            combinedFrame = {
+                x: minX,
+                y: minY,
+                width: maxX - minX,
+                height: maxY - minY
+            };
+        }
+    }
+    
+    console.log('📐 Combined frame calculation:');
+    console.log(`  Origin: (${combinedFrame.x}, ${combinedFrame.y})`);
+    console.log(`  Size: ${combinedFrame.width}x${combinedFrame.height}`);
+    console.log('');
+    
+    console.log('🔄 Coordinate conversion examples:');
+    displays.forEach((display, index) => {
+        console.log(`Display ${index} (${display.name}):`);
+        const localOriginX = display.x - combinedFrame.x;
+        const localOriginY = display.y - combinedFrame.y;
+        console.log(`  Global offset from combined: (${localOriginX}, ${localOriginY})`);
+        
+        // Test window at display origin
+        const testWindowGlobalX = display.x + 100;
+        const testWindowGlobalY = display.y + 100;
+        const localWindowX = testWindowGlobalX - combinedFrame.x;
+        const localWindowY = testWindowGlobalY - combinedFrame.y;
+        
+        console.log(`  Test window at (${testWindowGlobalX}, ${testWindowGlobalY}) global`);
+        console.log(`  -> Local coordinates: (${localWindowX}, ${localWindowY})`);
+        console.log('');
+    });
+}
+
+debugCoordinates();

package/package.json

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

package/src/mac_recorder.mm

@@ -451,13 +451,47 @@ Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
         NSArray *screens = [NSScreen screens];
         NSMutableArray *displays = [NSMutableArray array];
         
+        // Get real CGDirectDisplayIDs first
+        CGDirectDisplayID activeDisplays[32];
+        uint32_t displayCount;
+        CGGetActiveDisplayList(32, activeDisplays, &displayCount);
+        
         for (NSUInteger i = 0; i < [screens count]; i++) {
             NSScreen *screen = [screens objectAtIndex:i];
+            NSRect frame = [screen frame];
+            
+            // Find matching CGDirectDisplayID
+            CGDirectDisplayID displayID = 0;
+            bool isPrimary = false;
+            
+            for (uint32_t j = 0; j < displayCount; j++) {
+                CGDirectDisplayID candidateID = activeDisplays[j];
+                CGRect displayBounds = CGDisplayBounds(candidateID);
+                
+                if (fabs(frame.origin.x - displayBounds.origin.x) < 1.0 &&
+                    fabs(frame.origin.y - displayBounds.origin.y) < 1.0 &&
+                    fabs(frame.size.width - displayBounds.size.width) < 1.0 &&
+                    fabs(frame.size.height - displayBounds.size.height) < 1.0) {
+                    displayID = candidateID;
+                    isPrimary = (candidateID == CGMainDisplayID());
+                    break;
+                }
+            }
+            
+            // Fallback if no match found
+            if (displayID == 0 && i < displayCount) {
+                displayID = activeDisplays[i];
+                isPrimary = (displayID == CGMainDisplayID());
+            }
+            
             NSDictionary *displayInfo = @{
-                @"id": @(i + 1),
+                @"id": @(displayID),  // Use real display ID
                 @"name": [NSString stringWithFormat:@"Display %lu", (unsigned long)(i + 1)],
-                @"width": @((int)screen.frame.size.width),
-                @"height": @((int)screen.frame.size.height)
+                @"width": @((int)frame.size.width),
+                @"height": @((int)frame.size.height),
+                @"x": @((int)frame.origin.x),
+                @"y": @((int)frame.origin.y),
+                @"isPrimary": @(isPrimary)
             };
             [displays addObject:displayInfo];
         }

package/src/window_selector.mm

@@ -74,6 +74,7 @@ void updateScreenOverlays();
 @property (nonatomic) BOOL isActiveWindow;
 @property (nonatomic) BOOL isToggled;
 @property (nonatomic) NSRect highlightFrame;
+@property (nonatomic, strong) NSValue *globalOriginOffset; // Store global coordinate offset
 - (void)setHighlightFrame:(NSRect)frame;
 @end
 
@@ -863,10 +864,21 @@ void updateOverlay() {
                 }
             }
             
-            // No need to resize window since it's full-screen, just update the highlight area
+            // 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];
+            }
+            
+            // Convert global window position to local view position
+            CGFloat localX = x - globalOffset.x;
+            CGFloat localY = ([g_overlayView frame].size.height - (y - globalOffset.y)) - height;
+            
             // Update overlay view window info for highlighting
-            [(WindowSelectorOverlayView *)g_overlayView setWindowInfo:targetWindow];
-            [(WindowSelectorOverlayView *)g_overlayView setHighlightFrame:NSMakeRect(x, [g_overlayView frame].size.height - y - height, width, height)];
+            [overlayView setWindowInfo:targetWindow];
+            [overlayView setHighlightFrame:NSMakeRect(localX, localY, width, height)];
             
             // Only reset toggle state when switching to different window (not for position updates)
             if (!g_hasToggledWindow) {
@@ -967,19 +979,19 @@ void updateOverlay() {
             // Position buttons - Start Record in center of selected window
             if (g_selectButton) {
                 NSSize buttonSize = [g_selectButton frame].size;
-                // Use window center for positioning
-                CGFloat windowCenterX = x + (width / 2);
-                CGFloat windowCenterY = y + (height / 2);
+                // Use local window center for positioning
+                CGFloat localWindowCenterX = localX + (width / 2);
+                CGFloat localWindowCenterY = localY + (height / 2);
                 NSPoint buttonCenter = NSMakePoint(
-                    windowCenterX - (buttonSize.width / 2),
-                    windowCenterY - (buttonSize.height / 2)  // Perfect center of window
+                    localWindowCenterX - (buttonSize.width / 2),
+                    localWindowCenterY - (buttonSize.height / 2)  // Perfect center of window
                 );
                 [g_selectButton setFrameOrigin:buttonCenter];
                 
                 // Position app icon above window center
                 NSPoint iconCenter = NSMakePoint(
-                    windowCenterX - (96 / 2),  // Center horizontally on window
-                    windowCenterY + 120  // 120px above window center
+                    localWindowCenterX - (96 / 2),  // Center horizontally on window
+                    localWindowCenterY + 120  // 120px above window center
                 );
                 [appIconView setFrameOrigin:iconCenter];
                 NSLog(@"🎯 Positioning app icon at: (%.0f, %.0f) for window size: (%.0f, %.0f)", 
@@ -1001,8 +1013,8 @@ void updateOverlay() {
                 
                 // Position info label between icon and button relative to window center
                 NSPoint labelCenter = NSMakePoint(
-                    windowCenterX - ([infoLabel frame].size.width / 2),  // Center horizontally on window
-                    windowCenterY + 50  // 50px above window center, below icon
+                    localWindowCenterX - ([infoLabel frame].size.width / 2),  // Center horizontally on window
+                    localWindowCenterY + 50  // 50px above window center, below icon
                 );
                 [infoLabel setFrameOrigin:labelCenter];
                 
@@ -1019,8 +1031,8 @@ void updateOverlay() {
                 if (cancelButton) {
                     NSSize cancelButtonSize = [cancelButton frame].size;
                     NSPoint cancelButtonCenter = NSMakePoint(
-                        windowCenterX - (cancelButtonSize.width / 2),  // Center horizontally on window
-                        windowCenterY - 80  // 80px below window center
+                        localWindowCenterX - (cancelButtonSize.width / 2),  // Center horizontally on window
+                        localWindowCenterY - 80  // 80px below window center
                     );
                     [cancelButton setFrameOrigin:cancelButtonCenter];
                 }
@@ -1436,8 +1448,9 @@ bool startScreenSelection() {
             [overlayWindow setOpaque:NO];
             [overlayWindow setBackgroundColor:[NSColor clearColor]];
             
-            // Create overlay view
-            ScreenSelectorOverlayView *overlayView = [[ScreenSelectorOverlayView alloc] initWithFrame:screenFrame];
+            // Create overlay view - use local frame (0,0) not screen frame
+            NSRect localFrame = NSMakeRect(0, 0, screenFrame.size.width, screenFrame.size.height);
+            ScreenSelectorOverlayView *overlayView = [[ScreenSelectorOverlayView alloc] initWithFrame:localFrame];
             [overlayView setScreenInfo:screenInfo];
             [overlayWindow setContentView:overlayView];
             
@@ -1521,8 +1534,8 @@ bool startScreenSelection() {
             [screenCancelButton setFocusRingType:NSFocusRingTypeNone];
             [screenCancelButton setShowsBorderOnlyWhileMouseInside:NO];
             
-            // Create info label for screen
-            NSTextField *screenInfoLabel = [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, screenFrame.size.width - 40, 60)];
+            // Create info label for screen - use local coordinates
+            NSTextField *screenInfoLabel = [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, localFrame.size.width - 40, 60)];
             [screenInfoLabel setEditable:NO];
             [screenInfoLabel setSelectable:NO];
             [screenInfoLabel setBezeled:NO];
@@ -1548,17 +1561,17 @@ bool startScreenSelection() {
             NSString *resolution = [screenInfo objectForKey:@"resolution"] ?: @"Unknown Resolution";
             [screenInfoLabel setStringValue:[NSString stringWithFormat:@"%@\n%@", screenName, resolution]];
             
-            // Position buttons - Start Record in perfect center
+            // Position buttons - Start Record in perfect center using local coordinates
             NSPoint buttonCenter = NSMakePoint(
-                (screenFrame.size.width - [selectButton frame].size.width) / 2,
-                (screenFrame.size.height - [selectButton frame].size.height) / 2  // Perfect center
+                (localFrame.size.width - [selectButton frame].size.width) / 2,
+                (localFrame.size.height - [selectButton frame].size.height) / 2  // Perfect center
             );
             [selectButton setFrameOrigin:buttonCenter];
             
-            // Position screen icon above center
+            // Position screen icon above center using local coordinates
             NSPoint iconCenter = NSMakePoint(
-                (screenFrame.size.width - 96) / 2,  // Center horizontally (icon is 96px wide)
-                (screenFrame.size.height / 2) + 120  // 120px above center
+                (localFrame.size.width - 96) / 2,  // Center horizontally (icon is 96px wide)
+                (localFrame.size.height / 2) + 120  // 120px above center
             );
             [screenIconView setFrameOrigin:iconCenter];
             
@@ -1572,16 +1585,16 @@ bool startScreenSelection() {
             screenFloatAnimationX.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
             [screenIconView.layer addAnimation:screenFloatAnimationX forKey:@"floatAnimationX"];
             
-            // Position info label between icon and button
+            // Position info label between icon and button using local coordinates
             NSPoint labelCenter = NSMakePoint(
-                (screenFrame.size.width - [screenInfoLabel frame].size.width) / 2,  // Center horizontally
-                (screenFrame.size.height / 2) + 50  // 50px above center, below icon
+                (localFrame.size.width - [screenInfoLabel frame].size.width) / 2,  // Center horizontally
+                (localFrame.size.height / 2) + 50  // 50px above center, below icon
             );
             [screenInfoLabel setFrameOrigin:labelCenter];
             
             NSPoint cancelButtonCenter = NSMakePoint(
-                (screenFrame.size.width - [screenCancelButton frame].size.width) / 2,
-                (screenFrame.size.height / 2) - 80  // 80px below center
+                (localFrame.size.width - [screenCancelButton frame].size.width) / 2,
+                (localFrame.size.height / 2) - 80  // 80px below center
             );
             [screenCancelButton setFrameOrigin:cancelButtonCenter];
             
@@ -1801,9 +1814,21 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
             return env.Null();
         }
         
-        // Create full-screen overlay window to prevent window dragging
-        NSScreen *mainScreen = [NSScreen mainScreen];
-        NSRect fullScreenFrame = [mainScreen frame];
+        // Create multi-display overlay window to prevent window dragging
+        NSArray *allScreens = [NSScreen screens];
+        NSRect combinedFrame = NSZeroRect;
+        
+        // Calculate combined frame that covers all displays
+        for (NSScreen *screen in allScreens) {
+            NSRect screenFrame = [screen frame];
+            if (NSEqualRects(combinedFrame, NSZeroRect)) {
+                combinedFrame = screenFrame;
+            } else {
+                combinedFrame = NSUnionRect(combinedFrame, screenFrame);
+            }
+        }
+        
+        NSRect fullScreenFrame = combinedFrame;
         g_overlayWindow = [[NoFocusWindow alloc] initWithContentRect:fullScreenFrame
                                                            styleMask:NSWindowStyleMaskBorderless
                                                              backing:NSBackingStoreBuffered
@@ -1832,8 +1857,13 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
         [g_overlayWindow setOpaque:NO];
         [g_overlayWindow setBackgroundColor:[NSColor clearColor]];
         
-        // Create overlay view covering full screen
-        g_overlayView = [[WindowSelectorOverlayView alloc] initWithFrame:fullScreenFrame];
+        // 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 *)g_overlayView setValue:[NSValue valueWithPoint:fullScreenFrame.origin] forKey:@"globalOriginOffset"];
         [g_overlayWindow setContentView:g_overlayView];
         
         // Note: NSWindow doesn't have setWantsLayer method, only NSView does

package/test-multidisplay-fix.js

@@ -0,0 +1,120 @@
+const MacRecorder = require('./index');
+const WindowSelector = MacRecorder.WindowSelector;
+
+console.log('🧪 Testing multi-display fixes...');
+
+async function testDisplaySelection() {
+    console.log('\n🖥️ Testing display selection:');
+    
+    const recorder = new MacRecorder();
+    const displays = await recorder.getDisplays();
+    
+    console.log(`Found ${displays.length} displays:`);
+    displays.forEach((display, index) => {
+        console.log(`  ${index + 1}. ${display.name} (ID: ${display.id}) - ${display.resolution} at (${display.x}, ${display.y}) ${display.isPrimary ? '[PRIMARY]' : ''}`);
+    });
+    
+    // Test recording on each display
+    for (const display of displays) {
+        console.log(`\n📹 Testing recording on ${display.name}:`);
+        try {
+            const outputPath = `./test-output/display-${display.id}-test.mov`;
+            
+            await recorder.startRecording(outputPath, {
+                displayId: display.id,
+                captureCursor: false,
+                includeMicrophone: false,
+                includeSystemAudio: false
+            });
+            
+            console.log(`✅ Recording started on ${display.name}`);
+            
+            // Record for 2 seconds
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            await recorder.stopRecording();
+            console.log(`✅ Recording stopped on ${display.name}`);
+            
+        } catch (error) {
+            console.log(`❌ Recording failed on ${display.name}: ${error.message}`);
+        }
+        
+        // Small delay between tests
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+}
+
+async function testScreenSelector() {
+    console.log('\n🎯 Testing screen selector multi-display...');
+    
+    const selector = new WindowSelector();
+    
+    try {
+        console.log('🔍 Starting screen selection... (This should show overlays on ALL displays)');
+        await selector.startScreenSelection();
+        
+        console.log('⏱️ Screen selection UI is running...');
+        console.log('   - Check if overlays appear on ALL displays');
+        console.log('   - Check if buttons and text are positioned correctly');
+        console.log('   - Check if app icons are visible and animated');
+        
+        // Let it run for 10 seconds for manual inspection
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        
+        console.log('🛑 Stopping screen selection...');
+        await selector.stopScreenSelection();
+        
+    } catch (error) {
+        console.log(`❌ Screen selector test failed: ${error.message}`);
+    }
+}
+
+async function testWindowSelector() {
+    console.log('\n🪟 Testing window selector multi-display...');
+    
+    const selector = new WindowSelector();
+    
+    try {
+        console.log('🔍 Starting window selection... (This should work across ALL displays)');
+        await selector.startSelection();
+        
+        console.log('⏱️ Window selection UI is running...');
+        console.log('   - Move cursor to windows on different displays');
+        console.log('   - Check if highlighting works properly');
+        console.log('   - Check if buttons appear correctly over highlighted windows');
+        
+        // Let it run for 15 seconds for manual inspection
+        await new Promise(resolve => setTimeout(resolve, 15000));
+        
+        console.log('🛑 Stopping window selection...');
+        await selector.stopSelection();
+        
+    } catch (error) {
+        console.log(`❌ Window selector test failed: ${error.message}`);
+    }
+}
+
+async function runTests() {
+    try {
+        // Check permissions first
+        const recorder = new MacRecorder();
+        const permissions = await recorder.checkPermissions();
+        
+        if (!permissions.screenRecording) {
+            console.log('❌ Screen recording permission required. Enable in System Preferences > Security & Privacy > Privacy > Screen Recording');
+            return;
+        }
+        
+        await testDisplaySelection();
+        await testScreenSelector();
+        await testWindowSelector();
+        
+        console.log('\n🎉 Multi-display tests completed!');
+        
+    } catch (error) {
+        console.log(`❌ Test suite failed: ${error.message}`);
+        console.log(error.stack);
+    }
+}
+
+runTests();

package/test-window-selector-fix.js

@@ -0,0 +1,88 @@
+const MacRecorder = require('./index');
+const WindowSelector = MacRecorder.WindowSelector;
+
+async function testWindowSelector() {
+    console.log('🪟 Testing FIXED window selector multi-display...');
+    
+    const recorder = new MacRecorder();
+    const displays = await recorder.getDisplays();
+    
+    console.log('📊 Display setup:');
+    displays.forEach((display, index) => {
+        console.log(`  ${display.name}: ${display.resolution} at (${display.x}, ${display.y}) ${display.isPrimary ? '[PRIMARY]' : ''}`);
+    });
+    
+    const selector = new WindowSelector();
+    
+    try {
+        console.log('\n🔍 Starting window selection...');
+        console.log('   - Test windows on BOTH displays');
+        console.log('   - Check if buttons appear correctly positioned');
+        console.log('   - Primary display should now work correctly');
+        
+        await selector.startSelection();
+        
+        // Let it run for 20 seconds for thorough testing
+        await new Promise(resolve => setTimeout(resolve, 20000));
+        
+        console.log('🛑 Stopping window selection...');
+        await selector.stopSelection();
+        
+        console.log('✅ Window selector test completed!');
+        
+    } catch (error) {
+        console.log(`❌ Window selector test failed: ${error.message}`);
+        console.log(error.stack);
+    }
+}
+
+async function testSecondaryDisplayRecording() {
+    console.log('\n🎥 Testing secondary display recording...');
+    
+    const recorder = new MacRecorder();
+    const displays = await recorder.getDisplays();
+    
+    const secondaryDisplay = displays.find(d => !d.isPrimary);
+    if (!secondaryDisplay) {
+        console.log('⚠️ No secondary display found');
+        return;
+    }
+    
+    console.log(`🖥️ Testing recording on ${secondaryDisplay.name} (ID: ${secondaryDisplay.id})`);
+    
+    try {
+        const outputPath = `./test-output/secondary-display-fix-test.mov`;
+        
+        await recorder.startRecording(outputPath, {
+            displayId: secondaryDisplay.id,
+            captureCursor: true,
+            includeMicrophone: false,
+            includeSystemAudio: false
+        });
+        
+        console.log('✅ Recording started on secondary display');
+        
+        // Record for 3 seconds
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        
+        await recorder.stopRecording();
+        console.log('✅ Recording completed on secondary display');
+        
+    } catch (error) {
+        console.log(`❌ Secondary display recording failed: ${error.message}`);
+    }
+}
+
+async function runTests() {
+    try {
+        await testWindowSelector();
+        await testSecondaryDisplayRecording();
+        
+        console.log('\n🎉 All tests completed!');
+        
+    } catch (error) {
+        console.log(`❌ Test suite failed: ${error.message}`);
+    }
+}
+
+runTests();