node-mac-recorder 2.6.1 → 2.6.3

package/package.json

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

package/src/window_selector.mm

@@ -30,6 +30,8 @@ static NSMutableArray *g_screenOverlayWindows = nil;
 static NSDictionary *g_selectedScreenInfo = nil;
 static NSArray *g_allScreens = nil;
 static id g_screenKeyEventMonitor = nil;
+static NSTimer *g_screenTrackingTimer = nil;
+static NSInteger g_currentActiveScreenIndex = -1;
 
 // Forward declarations
 void cleanupWindowSelector();
@@ -46,6 +48,7 @@ bool stopScreenSelection();
 NSDictionary* getSelectedScreenInfo();
 bool showScreenRecordingPreview(NSDictionary *screenInfo);
 bool hideScreenRecordingPreview();
+void updateScreenOverlays();
 
 // Custom overlay view class
 @interface WindowSelectorOverlayView : NSView
@@ -139,6 +142,7 @@ bool hideScreenRecordingPreview();
 // Screen selection overlay view
 @interface ScreenSelectorOverlayView : NSView
 @property (nonatomic, strong) NSDictionary *screenInfo;
+@property (nonatomic) BOOL isActiveScreen;
 @end
 
 @implementation ScreenSelectorOverlayView
@@ -151,6 +155,7 @@ bool hideScreenRecordingPreview();
         // Ensure no borders or decorations
         self.layer.borderWidth = 0.0;
         self.layer.cornerRadius = 0.0;
+        self.isActiveScreen = NO;
     }
     return self;
 }
@@ -160,12 +165,23 @@ bool hideScreenRecordingPreview();
     
     if (!self.screenInfo) return;
     
-    // Background with transparency - purple tone (no border)
-    // Ensure no borders or frames are drawn
-    [[NSColor colorWithRed:0.5 green:0.3 blue:0.8 alpha:0.3] setFill];
+    // Background with transparency - purple tone varies by active state
+    if (self.isActiveScreen) {
+        // Active screen: brighter, more opaque
+        [[NSColor colorWithRed:0.6 green:0.4 blue:0.9 alpha:0.4] setFill];
+    } else {
+        // Inactive screen: dimmer, less opaque
+        [[NSColor colorWithRed:0.4 green:0.2 blue:0.6 alpha:0.25] setFill];
+    }
     NSRectFill(self.bounds);
     
-    // Text will be handled by separate label above button
+    // Add subtle border for active screen
+    if (self.isActiveScreen) {
+        [[NSColor colorWithRed:0.7 green:0.5 blue:1.0 alpha:0.6] setStroke];
+        NSBezierPath *borderPath = [NSBezierPath bezierPathWithRect:NSInsetRect(self.bounds, 2, 2)];
+        [borderPath setLineWidth:4.0];
+        [borderPath stroke];
+    }
 }
 
 @end
@@ -216,6 +232,10 @@ bool hideScreenRecordingPreview();
 - (void)timerUpdate:(NSTimer *)timer {
     updateOverlay();
 }
+
+- (void)screenTimerUpdate:(NSTimer *)timer {
+    updateScreenOverlays();
+}
 @end
 
 static WindowSelectorDelegate *g_delegate = nil;
@@ -766,10 +786,109 @@ bool hideRecordingPreview() {
     }
 }
 
+// Update screen overlays based on mouse position
+void updateScreenOverlays() {
+    @autoreleasepool {
+        if (!g_isScreenSelecting || !g_screenOverlayWindows || !g_allScreens) return;
+        
+        // Get current mouse position
+        NSPoint mouseLocation = [NSEvent mouseLocation];
+        // Convert from NSEvent coordinates (bottom-left) to screen coordinates
+        NSArray *screens = [NSScreen screens];
+        NSScreen *mouseScreen = nil;
+        NSInteger mouseScreenIndex = -1;
+        
+        // Find which screen contains the mouse
+        for (NSInteger i = 0; i < [screens count]; i++) {
+            NSScreen *screen = [screens objectAtIndex:i];
+            NSRect screenFrame = [screen frame];
+            
+            if (NSPointInRect(mouseLocation, screenFrame)) {
+                mouseScreen = screen;
+                mouseScreenIndex = i;
+                break;
+            }
+        }
+        
+        // If mouse screen changed, update overlays
+        if (mouseScreenIndex != g_currentActiveScreenIndex) {
+            g_currentActiveScreenIndex = mouseScreenIndex;
+            
+            // Update all screen overlays
+            for (NSInteger i = 0; i < [g_screenOverlayWindows count] && i < [screens count]; i++) {
+                NSWindow *overlayWindow = [g_screenOverlayWindows objectAtIndex:i];
+                ScreenSelectorOverlayView *overlayView = (ScreenSelectorOverlayView *)[overlayWindow contentView];
+                
+                // Update overlay appearance based on whether it's the active screen
+                bool isActiveScreen = (i == mouseScreenIndex);
+                
+                // Update overlay state and appearance
+                [overlayView setIsActiveScreen:isActiveScreen];
+                [overlayView setNeedsDisplay:YES];
+                
+                // Update UI elements based on active state
+                for (NSView *subview in [overlayView subviews]) {
+                    if ([subview isKindOfClass:[NSButton class]]) {
+                        NSButton *button = (NSButton *)subview;
+                        if ([button.title isEqualToString:@"Start Record"]) {
+                            if (isActiveScreen) {
+                                // Active screen: bright, prominent button
+                                [button.layer setBackgroundColor:[[NSColor colorWithRed:0.7 green:0.45 blue:0.9 alpha:1.0] CGColor]];
+                                [button setAlphaValue:1.0];
+                            } else {
+                                // Inactive screen: dimmer button
+                                [button.layer setBackgroundColor:[[NSColor colorWithRed:0.4 green:0.25 blue:0.55 alpha:0.8] CGColor]];
+                                [button setAlphaValue:0.7];
+                            }
+                        }
+                    }
+                    if ([subview isKindOfClass:[NSTextField class]]) {
+                        NSTextField *label = (NSTextField *)subview;
+                        if (isActiveScreen) {
+                            [label setTextColor:[NSColor whiteColor]];
+                            [label setAlphaValue:1.0];
+                        } else {
+                            [label setTextColor:[NSColor colorWithWhite:0.8 alpha:0.8]];
+                            [label setAlphaValue:0.7];
+                        }
+                    }
+                    if ([subview isKindOfClass:[NSImageView class]]) {
+                        NSImageView *imageView = (NSImageView *)subview;
+                        if (isActiveScreen) {
+                            [imageView setAlphaValue:1.0];
+                        } else {
+                            [imageView setAlphaValue:0.6];
+                        }
+                    }
+                }
+                
+                // Log active screen changes for debugging (optional)
+                if (isActiveScreen) {
+                    NSLog(@"🖥️ Active screen: Display %ld", (long)(i + 1));
+                }
+                
+                // Ensure ALL overlays are visible, but active one is on top
+                [overlayWindow orderFront:nil];
+                if (isActiveScreen) {
+                    [overlayWindow makeKeyAndOrderFront:nil];
+                } else {
+                    [overlayWindow orderFront:nil]; // Keep inactive screens visible too
+                }
+            }
+        }
+    }
+}
+
 // Screen selection functions
 void cleanupScreenSelector() {
     g_isScreenSelecting = false;
     
+    // Stop screen tracking timer
+    if (g_screenTrackingTimer) {
+        [g_screenTrackingTimer invalidate];
+        g_screenTrackingTimer = nil;
+    }
+    
     // Remove key event monitor
     if (g_screenKeyEventMonitor) {
         [NSEvent removeMonitor:g_screenKeyEventMonitor];
@@ -790,6 +909,9 @@ void cleanupScreenSelector() {
         [g_allScreens release];
         g_allScreens = nil;
     }
+    
+    // Reset active screen tracking
+    g_currentActiveScreenIndex = -1;
 }
 
 bool startScreenSelection() {
@@ -993,9 +1115,14 @@ bool startScreenSelection() {
             [overlayView addSubview:screenInfoLabel];
             [overlayView addSubview:selectButton];
             [overlayView addSubview:screenCancelButton];
+            
             [overlayWindow orderFront:nil];
             [overlayWindow makeKeyAndOrderFront:nil];
             
+            // Additional visibility settings
+            [overlayWindow setAlphaValue:1.0];
+            [overlayWindow setIsVisible:YES];
+            
             [g_screenOverlayWindows addObject:overlayWindow];
             [screenInfo release];
         }
@@ -1003,6 +1130,7 @@ bool startScreenSelection() {
         g_allScreens = [screenInfoArray retain];
         [screenInfoArray release];
         g_isScreenSelecting = true;
+        g_currentActiveScreenIndex = -1;
         
         // Add ESC key event monitor to cancel selection
         g_screenKeyEventMonitor = [NSEvent addGlobalMonitorForEventsMatchingMask:NSEventMaskKeyDown
@@ -1013,7 +1141,21 @@ bool startScreenSelection() {
             }
         }];
         
+        // Start screen tracking timer to update overlays based on mouse position
+        if (!g_delegate) {
+            g_delegate = [[WindowSelectorDelegate alloc] init];
+        }
+        g_screenTrackingTimer = [NSTimer scheduledTimerWithTimeInterval:0.05 // 20 FPS
+                                                                target:g_delegate
+                                                              selector:@selector(screenTimerUpdate:)
+                                                              userInfo:nil
+                                                               repeats:YES];
+        
+        // Initial update to set correct highlighting
+        updateScreenOverlays();
+        
         NSLog(@"🖥️ SCREEN SELECTION: Started with %lu screens (ESC to cancel)", (unsigned long)[screens count]);
+        NSLog(@"🖥️ SCREEN TRACKING: Timer started for overlay updates");
         
         return true;
         

package/test-multi-display-overlay.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+const WindowSelector = require('./window-selector');
+
+async function testMultiDisplayOverlay() {
+    console.log('🖥️ Multi-Display Overlay Test');
+    console.log('=============================\n');
+
+    const selector = new WindowSelector();
+    
+    try {
+        // Check permissions first
+        const permissions = await selector.checkPermissions();
+        console.log('🔐 Permissions:');
+        console.log(`   Screen Recording: ${permissions.screenRecording ? '✅' : '❌'}`);
+        console.log(`   Accessibility: ${permissions.accessibility ? '✅' : '❌'}\n`);
+
+        // Get display information
+        const MacRecorder = require('./index');
+        const recorder = new MacRecorder();
+        const displays = await recorder.getDisplays();
+        
+        console.log(`🖥️ Found ${displays.length} display(s):`);
+        displays.forEach((display, index) => {
+            console.log(`   Display ${index + 1}: ${display.name} (${display.resolution}) at (${display.x}, ${display.y}) ${display.isPrimary ? '🌟 PRIMARY' : ''}`);
+        });
+        console.log('');
+
+        if (displays.length < 2) {
+            console.log('⚠️ Only one display detected. Connect a second display to fully test multi-display overlay functionality.');
+            console.log('Continuing with single display test...\n');
+        }
+
+        let windowDetectionCount = 0;
+        let displaySwitchCount = 0;
+        let lastDisplayId = null;
+
+        // Event listeners for detailed tracking
+        selector.on('windowEntered', (window) => {
+            windowDetectionCount++;
+            
+            // Try to determine which display this window is on
+            let windowDisplayId = null;
+            const windowCenterX = window.x + window.width / 2;
+            const windowCenterY = window.y + window.height / 2;
+            
+            for (const display of displays) {
+                if (windowCenterX >= display.x && 
+                    windowCenterX < display.x + display.width &&
+                    windowCenterY >= display.y && 
+                    windowCenterY < display.y + display.height) {
+                    windowDisplayId = display.id;
+                    break;
+                }
+            }
+            
+            if (windowDisplayId !== lastDisplayId) {
+                displaySwitchCount++;
+                lastDisplayId = windowDisplayId;
+            }
+            
+            const displayName = displays.find(d => d.id === windowDisplayId)?.name || 'Unknown';
+            
+            console.log(`\n🎯 WINDOW DETECTED #${windowDetectionCount}:`);
+            console.log(`   App: ${window.appName}`);
+            console.log(`   Title: "${window.title}"`);
+            console.log(`   Position: (${window.x}, ${window.y})`);
+            console.log(`   Size: ${window.width} × ${window.height}`);
+            console.log(`   🖥️ Estimated Display: ${displayName} (ID: ${windowDisplayId})`);
+            console.log(`   Display switches so far: ${displaySwitchCount}`);
+            
+            if (displays.length > 1) {
+                console.log(`\n💡 Multi-Display Test Instructions:`);
+                console.log(`   • Move cursor to windows on different displays`);
+                console.log(`   • Overlay should follow cursor across displays`);
+                console.log(`   • Window detection should work on all displays`);
+            }
+        });
+
+        selector.on('windowLeft', (window) => {
+            console.log(`\n🚪 LEFT WINDOW: ${window.appName} - "${window.title}"`);
+        });
+
+        selector.on('windowSelected', (selectedWindow) => {
+            console.log('\n' + '🎉'.repeat(20));
+            console.log('🎯 WINDOW SELECTED!');
+            console.log('🎉'.repeat(20));
+            
+            const selectedDisplayName = displays.find(d => 
+                selectedWindow.x >= d.x && 
+                selectedWindow.x < d.x + d.width &&
+                selectedWindow.y >= d.y && 
+                selectedWindow.y < d.y + d.height
+            )?.name || 'Unknown';
+            
+            console.log(`\n📊 Selection Results:`);
+            console.log(`   Selected: ${selectedWindow.appName} - "${selectedWindow.title}"`);
+            console.log(`   Position: (${selectedWindow.x}, ${selectedWindow.y})`);
+            console.log(`   Size: ${selectedWindow.width} × ${selectedWindow.height}`);
+            console.log(`   Display: ${selectedDisplayName}`);
+            console.log(`\n📈 Test Statistics:`);
+            console.log(`   Total window detections: ${windowDetectionCount}`);
+            console.log(`   Display switches: ${displaySwitchCount}`);
+            console.log(`   Multi-display support: ${displaySwitchCount > 0 || displays.length === 1 ? '✅' : '❌'}`);
+            
+            process.exit(0);
+        });
+
+        // Interactive selection with instructions
+        console.log('🚀 Starting multi-display overlay test...\n');
+        console.log('📋 Test Instructions:');
+        console.log('   1. Move your cursor to windows on different displays');
+        console.log('   2. Watch for overlay following cursor across displays');
+        console.log('   3. Verify window detection works on all displays');
+        console.log('   4. Press ENTER when you want to select a window');
+        console.log('   5. Press ESC or Ctrl+C to cancel\n');
+
+        if (displays.length > 1) {
+            console.log('🖥️ Multi-Display Tips:');
+            console.log('   • Try windows on both primary and secondary displays');
+            console.log('   • Move cursor quickly between displays to test overlay tracking');
+            console.log('   • Overlay should appear on the display where the cursor is\n');
+        }
+
+        // Setup manual selection with ENTER key
+        const readline = require('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        rl.on('line', () => {
+            // Get current status to see if there's a window under cursor
+            const status = selector.getStatus();
+            if (status.nativeStatus && status.nativeStatus.currentWindow) {
+                selector.emit('windowSelected', status.nativeStatus.currentWindow);
+            } else {
+                console.log('\n⚠️ No window under cursor. Move cursor over a window first.');
+            }
+        });
+
+        await selector.startSelection();
+
+        // Status monitoring
+        let statusCount = 0;
+        const statusInterval = setInterval(() => {
+            statusCount++;
+            
+            if (statusCount % 40 === 0) { // Every 20 seconds
+                console.log(`\n⏱️ Status Update (${statusCount/2}s):`);
+                console.log(`   Window detections: ${windowDetectionCount}`);
+                console.log(`   Display switches: ${displaySwitchCount}`);
+                console.log(`   Current displays: ${displays.length}`);
+                if (displays.length > 1) {
+                    console.log(`   Multi-display overlay: ${displaySwitchCount > 0 ? '✅ Working' : '⏳ Waiting for cross-display movement'}`);
+                }
+            }
+        }, 500);
+
+        // Graceful shutdown
+        process.on('SIGINT', async () => {
+            clearInterval(statusInterval);
+            rl.close();
+            
+            console.log('\n\n🛑 Test stopped by user');
+            console.log('\n📊 Final Test Results:');
+            console.log(`   Total window detections: ${windowDetectionCount}`);
+            console.log(`   Display switches observed: ${displaySwitchCount}`);
+            console.log(`   Displays available: ${displays.length}`);
+            console.log(`   Multi-display support: ${displaySwitchCount > 0 || displays.length === 1 ? '✅ WORKING' : '❌ NEEDS INVESTIGATION'}`);
+            
+            await selector.cleanup();
+            console.log('✅ Cleanup completed');
+            process.exit(0);
+        });
+
+    } catch (error) {
+        console.error('\n❌ Test failed:', error.message);
+        process.exit(1);
+    }
+}
+
+if (require.main === module) {
+    testMultiDisplayOverlay();
+}

package/test-multi-screen-selection.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+const WindowSelector = require('./window-selector');
+
+async function testMultiScreenSelection() {
+    console.log('🖥️ Multi-Screen Selection Test');
+    console.log('==============================\n');
+
+    const selector = new WindowSelector();
+    
+    try {
+        // Check permissions first
+        const permissions = await selector.checkPermissions();
+        console.log('🔐 Permissions:');
+        console.log(`   Screen Recording: ${permissions.screenRecording ? '✅' : '❌'}`);
+        console.log(`   Accessibility: ${permissions.accessibility ? '✅' : '❌'}\n`);
+
+        if (!permissions.screenRecording || !permissions.accessibility) {
+            console.log('⚠️ Missing required permissions. Please grant permissions in System Preferences.');
+            process.exit(1);
+        }
+
+        // Get display information
+        const MacRecorder = require('./index');
+        const recorder = new MacRecorder();
+        const displays = await recorder.getDisplays();
+        
+        console.log(`🖥️ Found ${displays.length} display(s):`);
+        displays.forEach((display, index) => {
+            console.log(`   Display ${index + 1}: ${display.name} (${display.resolution}) at (${display.x}, ${display.y}) ${display.isPrimary ? '🌟 PRIMARY' : ''}`);
+        });
+        console.log('');
+
+        if (displays.length < 2) {
+            console.log('⚠️ Only one display detected. Connect a second display to fully test multi-screen selection functionality.');
+            console.log('Continuing with single display test...\n');
+        } else {
+            console.log('✅ Multiple displays detected. Perfect for multi-screen testing!\n');
+        }
+
+        console.log('🚀 Starting multi-screen selection test...\n');
+        console.log('📋 What to expect:');
+        console.log('   1. Overlay will appear on ALL screens simultaneously');
+        console.log('   2. The screen where your mouse is located will be HIGHLIGHTED (brighter)');
+        console.log('   3. Other screens will be dimmer');
+        console.log('   4. Move mouse between screens to see the highlighting change');
+        console.log('   5. Click "Start Record" on the screen you want to record');
+        console.log('   6. Press ESC to cancel\n');
+
+        if (displays.length > 1) {
+            console.log('🖱️ Multi-Screen Instructions:');
+            console.log('   • Move your mouse from one screen to another');
+            console.log('   • Watch the overlay highlighting follow your mouse');
+            console.log('   • Notice how the active screen becomes brighter');
+            console.log('   • All screens should show the overlay simultaneously\n');
+        }
+
+        console.log('⏱️ Starting screen selection in 3 seconds...');
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
+        // Start screen selection
+        const success = await selector.startScreenSelection();
+        
+        if (!success) {
+            console.error('❌ Failed to start screen selection');
+            process.exit(1);
+        }
+
+        console.log('✅ Screen selection started successfully!');
+        console.log('🖱️ Move your mouse between screens to test highlighting...\n');
+
+        // Monitor for selection completion
+        let checkCount = 0;
+        const selectionChecker = setInterval(() => {
+            checkCount++;
+            const selectedScreen = selector.getSelectedScreen();
+            
+            if (selectedScreen) {
+                clearInterval(selectionChecker);
+                
+                console.log('\n' + '🎉'.repeat(25));
+                console.log('🎯 SCREEN SELECTED!');
+                console.log('🎉'.repeat(25));
+                
+                console.log(`\n📊 Selected Screen Details:`);
+                console.log(`   Name: ${selectedScreen.name}`);
+                console.log(`   Resolution: ${selectedScreen.resolution}`);
+                console.log(`   Position: (${selectedScreen.x}, ${selectedScreen.y})`);
+                console.log(`   Size: ${selectedScreen.width} × ${selectedScreen.height}`);
+                console.log(`   Primary: ${selectedScreen.isPrimary ? 'Yes' : 'No'}`);
+                
+                console.log(`\n✅ Multi-screen selection test completed successfully!`);
+                console.log(`📈 Test ran for ${(checkCount * 100) / 1000} seconds`);
+                
+                process.exit(0);
+            }
+            
+            // Show progress every 5 seconds
+            if (checkCount % 50 === 0) {
+                const elapsed = (checkCount * 100) / 1000;
+                console.log(`⏱️ Test running for ${elapsed}s - Move mouse between screens to test highlighting`);
+                
+                if (displays.length > 1) {
+                    console.log('💡 Remember: The overlay should appear on ALL screens, but only the one with your mouse should be bright');
+                }
+            }
+        }, 100); // Check every 100ms
+
+        // Timeout after 60 seconds
+        setTimeout(() => {
+            clearInterval(selectionChecker);
+            console.log('\n⏰ Test timeout reached (60 seconds)');
+            console.log('🛑 Stopping screen selection...');
+            
+            selector.stopScreenSelection().then(() => {
+                console.log('✅ Screen selection stopped');
+                
+                if (displays.length > 1) {
+                    console.log('\n📊 Multi-Screen Test Summary:');
+                    console.log('   Expected behavior:');
+                    console.log('   ✓ Overlays should have appeared on all screens');
+                    console.log('   ✓ Mouse screen should have been highlighted brighter');
+                    console.log('   ✓ Non-mouse screens should have been dimmer');
+                    console.log('   ✓ Highlighting should have changed as you moved mouse');
+                } else {
+                    console.log('\n📊 Single-Screen Test Summary:');
+                    console.log('   ✓ Overlay should have appeared on your screen');
+                    console.log('   ✓ Screen should have been highlighted');
+                }
+                
+                process.exit(0);
+            }).catch((error) => {
+                console.error('❌ Error stopping screen selection:', error.message);
+                process.exit(1);
+            });
+        }, 60000);
+
+        // Handle Ctrl+C gracefully
+        process.on('SIGINT', async () => {
+            clearInterval(selectionChecker);
+            console.log('\n\n🛑 Test interrupted by user');
+            
+            try {
+                await selector.stopScreenSelection();
+                console.log('✅ Screen selection stopped');
+            } catch (error) {
+                console.log('⚠️ Error during cleanup:', error.message);
+            }
+            
+            console.log('\n📊 Test Results Summary:');
+            console.log(`   Displays available: ${displays.length}`);
+            console.log(`   Test duration: ${(checkCount * 100) / 1000} seconds`);
+            if (displays.length > 1) {
+                console.log('   Multi-screen support: Test interrupted before completion');
+            }
+            
+            process.exit(0);
+        });
+
+    } catch (error) {
+        console.error('\n❌ Test failed:', error.message);
+        if (error.stack) {
+            console.error('Stack trace:', error.stack);
+        }
+        process.exit(1);
+    }
+}
+
+if (require.main === module) {
+    testMultiScreenSelection();
+}