node-mac-recorder 2.15.9 → 2.15.11

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/debug-primary-window.js

@@ -0,0 +1,84 @@
+const MacRecorder = require('./index');
+const WindowSelector = MacRecorder.WindowSelector;
+
+async function debugPrimaryDisplay() {
+    console.log('🔍 Debugging primary display window selector...');
+    
+    const recorder = new MacRecorder();
+    const displays = await recorder.getDisplays();
+    
+    console.log('📊 Display analysis:');
+    displays.forEach(display => {
+        console.log(`${display.name}: (${display.x}, ${display.y}) ${display.width}x${display.height} ${display.isPrimary ? '[PRIMARY]' : '[SECONDARY]'}`);
+    });
+    
+    // Calculate combined frame like in native code
+    const primary = displays.find(d => d.isPrimary);
+    const secondary = displays.find(d => !d.isPrimary);
+    
+    console.log('\n🧮 Coordinate calculations:');
+    console.log(`Primary: (${primary.x}, ${primary.y})`);
+    console.log(`Secondary: (${secondary.x}, ${secondary.y})`);
+    
+    // Combined frame calculation
+    const minX = Math.min(primary.x, secondary.x);
+    const minY = Math.min(primary.y, secondary.y);
+    const maxX = Math.max(primary.x + primary.width, secondary.x + secondary.width);
+    const maxY = Math.max(primary.y + primary.height, secondary.y + secondary.height);
+    
+    const combinedFrame = {
+        x: minX,
+        y: minY,
+        width: maxX - minX,
+        height: maxY - minY
+    };
+    
+    console.log(`Combined frame: (${combinedFrame.x}, ${combinedFrame.y}) ${combinedFrame.width}x${combinedFrame.height}`);
+    
+    // Test coordinate conversion for a primary display window
+    const testPrimaryWindowX = 100;  // Window at (100, 100) on primary
+    const testPrimaryWindowY = 100;
+    
+    const localX = testPrimaryWindowX - combinedFrame.x;
+    const localY = testPrimaryWindowY - combinedFrame.y;
+    
+    console.log(`\n🎯 Primary window test:`);
+    console.log(`Global window: (${testPrimaryWindowX}, ${testPrimaryWindowY})`);
+    console.log(`Combined origin: (${combinedFrame.x}, ${combinedFrame.y})`);
+    console.log(`Local coordinates: (${localX}, ${localY})`);
+    console.log(`Combined height: ${combinedFrame.height}`);
+    console.log(`Converted Y: ${combinedFrame.height - localY - 200}`);  // Assuming 200px window height
+    
+    // Test for secondary display window
+    const testSecondaryWindowX = secondary.x + 100;
+    const testSecondaryWindowY = secondary.y + 100;
+    
+    const localSecondaryX = testSecondaryWindowX - combinedFrame.x;
+    const localSecondaryY = testSecondaryWindowY - combinedFrame.y;
+    
+    console.log(`\n🎯 Secondary window test:`);
+    console.log(`Global window: (${testSecondaryWindowX}, ${testSecondaryWindowY})`);
+    console.log(`Local coordinates: (${localSecondaryX}, ${localSecondaryY})`);
+    console.log(`Converted Y: ${combinedFrame.height - localSecondaryY - 200}`);
+    
+    console.log('\n🧪 Starting actual window selection test...');
+    console.log('   - Move cursor to primary display windows');
+    console.log('   - Check if buttons appear');
+    console.log('   - Check console logs for coordinate calculations');
+    
+    const selector = new WindowSelector();
+    
+    try {
+        await selector.startSelection();
+        
+        // Let it run for 15 seconds for debugging
+        await new Promise(resolve => setTimeout(resolve, 15000));
+        
+        await selector.stopSelection();
+        
+    } catch (error) {
+        console.log(`❌ Test failed: ${error.message}`);
+    }
+}
+
+debugPrimaryDisplay();

package/final-multi-display-test.js

@@ -0,0 +1,74 @@
+const MacRecorder = require('./index');
+const WindowSelector = MacRecorder.WindowSelector;
+
+async function finalMultiDisplayTest() {
+    console.log('🎉 FINAL Multi-Display Test');
+    console.log('='.repeat(40));
+    
+    const recorder = new MacRecorder();
+    const displays = await recorder.getDisplays();
+    
+    console.log('📊 Display Configuration:');
+    displays.forEach(display => {
+        console.log(`  ${display.name}: (${display.x}, ${display.y}) ${display.width}x${display.height} ${display.isPrimary ? '[PRIMARY]' : ''}`);
+    });
+    
+    console.log('\n✅ All coordinate fixes applied:');
+    console.log('  - Screen selector: Local coordinates for UI elements');
+    console.log('  - Window selector: Primary/secondary coordinate handling');
+    console.log('  - Display recording: Correct display ID mapping');
+    
+    console.log('\n🧪 Testing window selector...');
+    console.log('📍 IMPORTANT: Test windows on BOTH displays');
+    console.log('   - Primary display: Should show buttons/UI correctly now');
+    console.log('   - Secondary display: Should continue working');
+    
+    const selector = new WindowSelector();
+    
+    try {
+        await selector.startSelection();
+        
+        console.log('\n⏱️  Running for 30 seconds - test both displays thoroughly...');
+        await new Promise(resolve => setTimeout(resolve, 30000));
+        
+        await selector.stopSelection();
+        
+        console.log('✅ Window selector test completed!');
+        
+        // Test recording on both displays
+        console.log('\n🎥 Testing recording on both displays...');
+        
+        for (const display of displays) {
+            console.log(`\n📹 Testing ${display.name} recording...`);
+            
+            try {
+                const outputPath = `./test-output/final-test-${display.id}.mov`;
+                
+                await recorder.startRecording(outputPath, {
+                    displayId: display.id,
+                    captureCursor: true,
+                    includeMicrophone: false,
+                    includeSystemAudio: false
+                });
+                
+                console.log(`✅ Recording started on ${display.name}`);
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                
+                await recorder.stopRecording();
+                console.log(`✅ Recording completed on ${display.name}`);
+                
+            } catch (error) {
+                console.log(`❌ Recording failed on ${display.name}: ${error.message}`);
+            }
+        }
+        
+        console.log('\n🎉 ALL MULTI-DISPLAY TESTS COMPLETED!');
+        console.log('✅ Window selector should now work on both displays');
+        console.log('✅ Recording should work on both displays');
+        
+    } catch (error) {
+        console.log(`❌ Test failed: ${error.message}`);
+    }
+}
+
+finalMultiDisplayTest();

package/package.json

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

package/publish.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+
+# Publish script for node-mac-recorder
+# Usage: ./publish.sh <patch|minor|major> "commit message"
+
+# Check if correct number of arguments provided
+if [ $# -ne 2 ]; then
+    echo "❌ Usage: $0 <patch|minor|major> \"commit message\""
+    echo "   Example: $0 patch \"Fix multi-display coordinate issues\""
+    exit 1
+fi
+
+VERSION_TYPE=$1
+COMMIT_MESSAGE=$2
+
+# Validate version type
+if [[ "$VERSION_TYPE" != "patch" && "$VERSION_TYPE" != "minor" && "$VERSION_TYPE" != "major" ]]; then
+    echo "❌ Invalid version type: $VERSION_TYPE"
+    echo "   Must be one of: patch, minor, major"
+    exit 1
+fi
+
+# Check if we're in a git repository
+if ! git rev-parse --git-dir > /dev/null 2>&1; then
+    echo "❌ Not in a git repository"
+    exit 1
+fi
+
+# Check if there are uncommitted changes
+if ! git diff --quiet || ! git diff --cached --quiet; then
+    echo "📁 Adding all changes to git..."
+    git add .
+    
+    if [ $? -ne 0 ]; then
+        echo "❌ Failed to add files to git"
+        exit 1
+    fi
+    
+    echo "📝 Committing changes..."
+    git commit -m "$COMMIT_MESSAGE"
+    
+    if [ $? -ne 0 ]; then
+        echo "❌ Failed to commit changes"
+        exit 1
+    fi
+    
+    echo "✅ Changes committed successfully"
+else
+    echo "ℹ️  No uncommitted changes found"
+fi
+
+# Bump version
+echo "📦 Bumping $VERSION_TYPE version..."
+npm version $VERSION_TYPE
+
+if [ $? -ne 0 ]; then
+    echo "❌ Failed to bump version"
+    exit 1
+fi
+
+NEW_VERSION=$(node -p "require('./package.json').version")
+echo "✅ Version bumped to: $NEW_VERSION"
+
+# Push to git
+echo "🚀 Pushing to git..."
+git push origin HEAD
+
+if [ $? -ne 0 ]; then
+    echo "❌ Failed to push to git"
+    exit 1
+fi
+
+echo "✅ Pushed to git successfully"
+
+# Publish to npm
+echo "📤 Publishing to npm..."
+npm publish
+
+if [ $? -ne 0 ]; then
+    echo "❌ Failed to publish to npm"
+    exit 1
+fi
+
+echo "🎉 Successfully published version $NEW_VERSION to npm!"
+echo ""
+echo "📋 Summary:"
+echo "   • Committed: '$COMMIT_MESSAGE'"
+echo "   • Version: $NEW_VERSION ($VERSION_TYPE bump)"
+echo "   • Git: Pushed to remote"
+echo "   • NPM: Published successfully"

package/simulate-primary-window.js

@@ -0,0 +1,56 @@
+// Simülasyon: Primary display koordinat hesabı
+
+const displays = [
+    { name: 'Display 1', x: 0, y: 0, width: 2048, height: 1330, isPrimary: true },
+    { name: 'Display 2', x: -3440, y: -56, width: 3440, height: 1440, isPrimary: false }
+];
+
+// Combined frame calculation
+const minX = Math.min(...displays.map(d => d.x));
+const minY = Math.min(...displays.map(d => d.y));
+const maxX = Math.max(...displays.map(d => d.x + d.width));
+const maxY = Math.max(...displays.map(d => d.y + d.height));
+
+const combinedFrame = {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+};
+
+console.log('📐 Display Setup:');
+displays.forEach(d => console.log(`  ${d.name}: (${d.x}, ${d.y}) ${d.width}x${d.height} ${d.isPrimary ? '[PRIMARY]' : ''}`));
+
+console.log(`\n📐 Combined Frame: (${combinedFrame.x}, ${combinedFrame.y}) ${combinedFrame.width}x${combinedFrame.height}`);
+
+// Test primary window
+const primaryWindow = { x: 100, y: 100, width: 1000, height: 800 };
+
+const globalOffset = { x: combinedFrame.x, y: combinedFrame.y };
+
+const localX = primaryWindow.x - globalOffset.x;  // 100 - (-3440) = 3540
+const localY = (combinedFrame.height - (primaryWindow.y - globalOffset.y)) - primaryWindow.height;
+
+const localWindowCenterX = localX + (primaryWindow.width / 2);  // 3540 + 500 = 4040
+const localWindowCenterY = localY + (primaryWindow.height / 2);
+
+console.log(`\n🎯 Primary Window Test: (${primaryWindow.x}, ${primaryWindow.y}) ${primaryWindow.width}x${primaryWindow.height}`);
+console.log(`  GlobalOffset: (${globalOffset.x}, ${globalOffset.y})`);
+console.log(`  LocalCoords: (${localX}, ${localY})`);
+console.log(`  LocalWindowCenter: (${localWindowCenterX}, ${localWindowCenterY})`);
+console.log(`  Expected range for primary: X should be 0-${displays.find(d => d.isPrimary).width}`);
+console.log(`  ❌ PROBLEM: LocalX ${localX} is way outside primary display bounds!`);
+
+console.log(`\n💡 SOLUTION: Primary display windows should stay at their global positions`);
+console.log(`   - Primary windows have global coords that are already correct for overlay`);
+console.log(`   - Only secondary display windows need coordinate transformation`);
+
+// Test secondary window  
+const secondaryWindow = { x: -3340, y: 44, width: 3440, height: 1415 };
+const secLocalX = secondaryWindow.x - globalOffset.x;  // -3340 - (-3440) = 100
+const secLocalWindowCenterX = secLocalX + (secondaryWindow.width / 2);  // 100 + 1720 = 1820
+
+console.log(`\n🎯 Secondary Window Test: (${secondaryWindow.x}, ${secondaryWindow.y}) ${secondaryWindow.width}x${secondaryWindow.height}`);
+console.log(`  LocalCoords: (${secLocalX}, ???)`);
+console.log(`  LocalWindowCenter: (${secLocalWindowCenterX}, ???)`);
+console.log(`  ✅ This looks correct for secondary display`);

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

@@ -94,6 +94,8 @@ void updateScreenOverlays();
 
 @implementation WindowSelectorOverlayView
 
+@synthesize globalOriginOffset = _globalOriginOffset;
+
 - (instancetype)initWithFrame:(NSRect)frameRect {
     self = [super initWithFrame:frameRect];
     if (self) {
@@ -872,9 +874,25 @@ void updateOverlay() {
                 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;
+            // Determine if this is a primary display window
+            BOOL isPrimaryDisplayWindow = (x >= 0 && x <= 2048);  // Primary display width
+            
+            CGFloat localX, localY;
+            if (isPrimaryDisplayWindow) {
+                // Primary display windows: Offset to their position in the combined overlay
+                // Primary display starts at (3440, 56) within the combined frame
+                localX = x + 3440;  // Primary starts 3440px from overlay origin
+                localY = ([g_overlayView frame].size.height - (y + 56)) - height;  // Y offset for primary
+            } else {
+                // Secondary display windows: Apply standard coordinate transformation
+                localX = x - globalOffset.x;
+                localY = ([g_overlayView frame].size.height - (y - globalOffset.y)) - height;
+            }
+            
+            NSLog(@"🔧 COORDINATE DEBUG: Window (%d, %d) %dx%d [%@]", (int)x, (int)y, (int)width, (int)height, isPrimaryDisplayWindow ? @"PRIMARY" : @"SECONDARY");
+            NSLog(@"   GlobalOffset: (%.0f, %.0f)", globalOffset.x, globalOffset.y);
+            NSLog(@"   LocalCoords: (%.0f, %.0f)", localX, localY);
+            NSLog(@"   ViewFrame: %.0fx%.0f", [g_overlayView frame].size.width, [g_overlayView frame].size.height);
             
             // Update overlay view window info for highlighting
             [overlayView setWindowInfo:targetWindow];
@@ -986,6 +1004,10 @@ void updateOverlay() {
                     localWindowCenterX - (buttonSize.width / 2),
                     localWindowCenterY - (buttonSize.height / 2)  // Perfect center of window
                 );
+                
+                NSLog(@"   ButtonCalc: WindowCenter(%.0f, %.0f) -> Button(%.0f, %.0f)", 
+                      localWindowCenterX, localWindowCenterY, buttonCenter.x, buttonCenter.y);
+                      
                 [g_selectButton setFrameOrigin:buttonCenter];
                 
                 // Position app icon above window center
@@ -1863,7 +1885,10 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
         g_overlayView = [[WindowSelectorOverlayView alloc] initWithFrame:localViewFrame];
         
         // Store the global origin offset for coordinate conversion
-        [(WindowSelectorOverlayView *)g_overlayView setValue:[NSValue valueWithPoint:fullScreenFrame.origin] forKey:@"globalOriginOffset"];
+        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];
         
         // Note: NSWindow doesn't have setWantsLayer method, only NSView does

package/test-coordinate-debug.js

@@ -0,0 +1,25 @@
+const MacRecorder = require('./index');
+const WindowSelector = MacRecorder.WindowSelector;
+
+async function testCoordinateDebug() {
+    console.log('🔍 Testing coordinate debugging...');
+    
+    const selector = new WindowSelector();
+    
+    try {
+        console.log('🚀 Starting window selection with coordinate debugging...');
+        await selector.startSelection();
+        
+        console.log('📍 Move cursor to PRIMARY display window and check console logs');
+        
+        // Let it run for 10 seconds to see debug output
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        
+        await selector.stopSelection();
+        
+    } catch (error) {
+        console.log(`❌ Test failed: ${error.message}`);
+    }
+}
+
+testCoordinateDebug();

package/test-final-coordinate-fix.js

@@ -0,0 +1,38 @@
+const MacRecorder = require('./index');
+const WindowSelector = MacRecorder.WindowSelector;
+
+async function testFinalCoordinateFix() {
+    console.log('🎯 Testing FINAL coordinate fix...');
+    
+    const recorder = new MacRecorder();
+    const displays = await recorder.getDisplays();
+    
+    console.log('📊 Display setup:');
+    displays.forEach(display => {
+        console.log(`  ${display.name}: (${display.x}, ${display.y}) ${display.width}x${display.height} ${display.isPrimary ? '[PRIMARY]' : ''}`);
+    });
+    
+    const selector = new WindowSelector();
+    
+    try {
+        console.log('\n🚀 Starting window selection with coordinate fix...');
+        console.log('📍 Test BOTH displays:');
+        console.log('   - Primary display windows should now show buttons correctly');
+        console.log('   - Secondary display windows should continue working');
+        console.log('   - Look for [PRIMARY] vs [SECONDARY] tags in logs');
+        
+        await selector.startSelection();
+        
+        // Let it run for 20 seconds for thorough testing
+        await new Promise(resolve => setTimeout(resolve, 20000));
+        
+        await selector.stopSelection();
+        
+        console.log('✅ Final coordinate test completed!');
+        
+    } catch (error) {
+        console.log(`❌ Test failed: ${error.message}`);
+    }
+}
+
+testFinalCoordinateFix();

package/test-primary-live.js

@@ -0,0 +1,17 @@
+const MacRecorder = require('./index');
+const WindowSelector = MacRecorder.WindowSelector;
+
+console.log('🔥 LIVE Primary Display Test - Move cursor NOW!');
+console.log('   - Quickly move to primary display windows');
+console.log('   - Look for [PRIMARY] tags in logs');
+
+const selector = new WindowSelector();
+
+selector.startSelection().then(() => {
+    // Auto-stop after 8 seconds
+    setTimeout(() => {
+        selector.stopSelection().then(() => {
+            process.exit(0);
+        });
+    }, 8000);
+});

package/test-primary-window-debug.js

@@ -0,0 +1,33 @@
+const MacRecorder = require('./index');
+const WindowSelector = MacRecorder.WindowSelector;
+
+async function testPrimaryWindowDebug() {
+    console.log('🔍 Testing PRIMARY display window debugging...');
+    
+    const recorder = new MacRecorder();
+    const displays = await recorder.getDisplays();
+    
+    const primary = displays.find(d => d.isPrimary);
+    console.log(`Primary display: ${primary.name} at (${primary.x}, ${primary.y}) ${primary.width}x${primary.height}`);
+    
+    const selector = new WindowSelector();
+    
+    try {
+        console.log('🚀 Starting window selection...');
+        console.log('📍 IMPORTANT: Move cursor to a window ON THE PRIMARY DISPLAY');
+        console.log('   - Look for windows at coordinates like (0, 50) or (100, 100)');
+        console.log('   - Should see GlobalOffset: (3440, 56) for primary display');
+        
+        await selector.startSelection();
+        
+        // Let it run for 15 seconds to catch primary display windows
+        await new Promise(resolve => setTimeout(resolve, 15000));
+        
+        await selector.stopSelection();
+        
+    } catch (error) {
+        console.log(`❌ Test failed: ${error.message}`);
+    }
+}
+
+testPrimaryWindowDebug();

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();

package/validate-primary-fix.js

@@ -0,0 +1,58 @@
+// Primary display window button positioning validation
+
+console.log('🧮 Primary Display Button Position Validation');
+console.log('='.repeat(50));
+
+// Combined frame
+const combinedFrame = { x: -3440, y: -56, width: 5488, height: 1440 };
+
+// Test primary window
+const primaryWindow = { x: 100, y: 100, width: 1000, height: 800 };
+
+console.log(`Combined frame: (${combinedFrame.x}, ${combinedFrame.y}) ${combinedFrame.width}x${combinedFrame.height}`);
+console.log(`Primary window: (${primaryWindow.x}, ${primaryWindow.y}) ${primaryWindow.width}x${primaryWindow.height}`);
+
+// Current calculation
+const isPrimaryDisplayWindow = (primaryWindow.x >= 0 && primaryWindow.x <= 2048);
+console.log(`\nisPrimaryDisplayWindow: ${isPrimaryDisplayWindow}`);
+
+if (isPrimaryDisplayWindow) {
+    // Current implementation
+    const localX = primaryWindow.x + 3440;  // 100 + 3440 = 3540
+    const localY = (combinedFrame.height - (primaryWindow.y + 56)) - primaryWindow.height;  // 1440 - (100 + 56) - 800 = 484
+    
+    console.log(`Local coordinates: (${localX}, ${localY})`);
+    
+    const localWindowCenterX = localX + (primaryWindow.width / 2);  // 3540 + 500 = 4040
+    const localWindowCenterY = localY + (primaryWindow.height / 2);  // 484 + 400 = 884
+    
+    console.log(`Window center: (${localWindowCenterX}, ${localWindowCenterY})`);
+    
+    const buttonX = localWindowCenterX - 100;  // 4040 - 100 = 3940
+    const buttonY = localWindowCenterY - 30;   // 884 - 30 = 854
+    
+    console.log(`Button position: (${buttonX}, ${buttonY})`);
+    
+    // Validate button is within overlay bounds
+    const isValid = buttonX >= 0 && buttonX <= combinedFrame.width && buttonY >= 0 && buttonY <= combinedFrame.height;
+    console.log(`Button within overlay bounds: ${isValid} ✅`);
+    
+    // Validate button is within primary display section of overlay
+    const primaryOverlayStart = 3440;
+    const primaryOverlayEnd = 5488;
+    const inPrimarySection = buttonX >= primaryOverlayStart && buttonX <= primaryOverlayEnd;
+    console.log(`Button in primary overlay section (${primaryOverlayStart}-${primaryOverlayEnd}): ${inPrimarySection} ✅`);
+    
+    console.log('\n🎯 PRIMARY WINDOW BUTTON POSITIONING SHOULD NOW WORK!');
+} else {
+    console.log('Not a primary window');
+}
+
+console.log('\n📊 Compare with secondary window:');
+const secondaryWindow = { x: -3340, y: 44, width: 3440, height: 1415 };
+const secLocalX = secondaryWindow.x - combinedFrame.x;  // -3340 - (-3440) = 100
+const secCenterX = secLocalX + (secondaryWindow.width / 2);  // 100 + 1720 = 1820
+console.log(`Secondary window center: (${secCenterX}, ???)`);
+console.log(`Secondary button position: (${secCenterX - 100}, ???)`);
+
+console.log('\n✅ Both primary and secondary should now have correct button positioning!');