node-mac-recorder 2.4.8 → 2.4.10

package/index.js

@@ -950,6 +950,63 @@ class MacRecorder extends EventEmitter {
 
 		return Promise.all(windowPromises);
 	}
+
+	// Window Selection Methods (ScreenCaptureKit compatible)
+	startWindowSelection() {
+		if (!nativeBinding.startWindowSelection) {
+			throw new Error('Window selection is not available in this build');
+		}
+		return nativeBinding.startWindowSelection();
+	}
+
+	stopWindowSelection() {
+		if (!nativeBinding.stopWindowSelection) {
+			return false;
+		}
+		return nativeBinding.stopWindowSelection();
+	}
+
+	getSelectedWindowInfo() {
+		if (!nativeBinding.getSelectedWindowInfo) {
+			return null;
+		}
+		return nativeBinding.getSelectedWindowInfo();
+	}
+
+	getWindowSelectionStatus() {
+		if (!nativeBinding.getWindowSelectionStatus) {
+			return { isSelecting: false, hasSelectedWindow: false };
+		}
+		return nativeBinding.getWindowSelectionStatus();
+	}
+
+	bringWindowToFront(windowId) {
+		if (!nativeBinding.bringWindowToFront) {
+			return false;
+		}
+		return nativeBinding.bringWindowToFront(windowId);
+	}
+
+	setBringToFrontEnabled(enabled) {
+		if (!nativeBinding.setBringToFrontEnabled) {
+			return false;
+		}
+		return nativeBinding.setBringToFrontEnabled(enabled);
+	}
+
+	showRecordingPreview(windowInfo) {
+		if (!nativeBinding.showRecordingPreview) {
+			return false;
+		}
+		return nativeBinding.showRecordingPreview(windowInfo);
+	}
+
+	hideRecordingPreview() {
+		if (!nativeBinding.hideRecordingPreview) {
+			return false;
+		}
+		return nativeBinding.hideRecordingPreview();
+	}
 }
 
 // WindowSelector modülünü de export edelim

package/package.json

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

package/src/mac_recorder.mm

@@ -770,8 +770,33 @@ Napi::Value GetWindows(const Napi::CallbackInfo& info) {
             Napi::Object windowObj = Napi::Object::New(env);
             windowObj.Set("id", Napi::Number::New(env, window.windowID));
             windowObj.Set("title", Napi::String::New(env, window.title ? [window.title UTF8String] : ""));
-            windowObj.Set("ownerName", Napi::String::New(env, window.owningApplication.applicationName ? [window.owningApplication.applicationName UTF8String] : ""));
-            windowObj.Set("bounds", Napi::Object::New(env)); // TODO: Add bounds details
+            
+            // Safely get application information (can be nil for some windows)
+            NSString *appName = @"";
+            NSString *bundleId = @"";
+            if (window.owningApplication) {
+                appName = window.owningApplication.applicationName ?: @"";
+                bundleId = window.owningApplication.bundleIdentifier ?: @"";
+            }
+            
+            windowObj.Set("appName", Napi::String::New(env, [appName UTF8String]));
+            windowObj.Set("ownerName", Napi::String::New(env, [appName UTF8String]));
+            windowObj.Set("bundleId", Napi::String::New(env, [bundleId UTF8String]));
+            
+            // Add frame details
+            CGRect frame = window.frame;
+            windowObj.Set("x", Napi::Number::New(env, (int)frame.origin.x));
+            windowObj.Set("y", Napi::Number::New(env, (int)frame.origin.y));
+            windowObj.Set("width", Napi::Number::New(env, (int)frame.size.width));
+            windowObj.Set("height", Napi::Number::New(env, (int)frame.size.height));
+            
+            // Legacy bounds object for compatibility
+            Napi::Object boundsObj = Napi::Object::New(env);
+            boundsObj.Set("x", Napi::Number::New(env, (int)frame.origin.x));
+            boundsObj.Set("y", Napi::Number::New(env, (int)frame.origin.y));
+            boundsObj.Set("width", Napi::Number::New(env, (int)frame.size.width));
+            boundsObj.Set("height", Napi::Number::New(env, (int)frame.size.height));
+            windowObj.Set("bounds", boundsObj);
             
             windowsArray.Set(index++, windowObj);
         }

package/src/window_selector.mm

@@ -5,6 +5,7 @@
 #import <ApplicationServices/ApplicationServices.h>
 #import <Carbon/Carbon.h>
 #import <Accessibility/Accessibility.h>
+#import <ScreenCaptureKit/ScreenCaptureKit.h>
 
 // Global state for window selection
 static bool g_isWindowSelecting = false;
@@ -35,6 +36,7 @@ void cleanupWindowSelector();
 void updateOverlay();
 NSDictionary* getWindowUnderCursor(CGPoint point);
 NSArray* getAllSelectableWindows();
+NSArray* getAllSelectableWindowsLegacy();
 bool bringWindowToFront(int windowId);
 void cleanupRecordingPreview();
 bool showRecordingPreview(NSDictionary *windowInfo);
@@ -233,7 +235,7 @@ bool hideScreenRecordingPreview();
     NSInteger screenIndex = [button tag];
     
     // Get screen info from global array using button tag
-    if (g_allScreens && screenIndex >= 0 && screenIndex < [g_allScreens count]) {
+    if (g_allScreens && screenIndex >= 0 && screenIndex < (NSInteger)[g_allScreens count]) {
         NSDictionary *screenInfo = [g_allScreens objectAtIndex:screenIndex];
         g_selectedScreenInfo = [screenInfo copy];
         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.05 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
@@ -367,8 +369,83 @@ bool bringWindowToFront(int windowId) {
     }
 }
 
-// Get all selectable windows
+// Get all selectable windows using ScreenCaptureKit
 NSArray* getAllSelectableWindows() {
+    @autoreleasepool {
+        NSMutableArray *windows = [NSMutableArray array];
+        
+        // Check if ScreenCaptureKit is available (requires macOS 12.3+)
+        if (@available(macOS 12.3, *)) {
+            // Use dispatch_semaphore for synchronous SCShareableContent retrieval
+            dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+            __block SCShareableContent *content = nil;
+            __block NSError *error = nil;
+            
+            [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *shareableContent, NSError *contentError) {
+                content = shareableContent;
+                error = contentError;
+                dispatch_semaphore_signal(semaphore);
+            }];
+            
+            // Wait for completion (timeout after 5 seconds)
+            dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC);
+            if (dispatch_semaphore_wait(semaphore, timeout) == 0 && content) {
+                NSLog(@"✅ ScreenCaptureKit: Found %lu windows", (unsigned long)content.windows.count);
+                
+                for (SCWindow *scWindow in content.windows) {
+                    // Skip windows without proper frame or title
+                    if (scWindow.frame.size.width < 50 || scWindow.frame.size.height < 50) continue;
+                    if (!scWindow.owningApplication) continue;
+                    
+                    // Skip system applications
+                    NSString *bundleId = scWindow.owningApplication.bundleIdentifier;
+                    NSString *appName = scWindow.owningApplication.applicationName;
+                    if ([bundleId hasPrefix:@"com.apple.dock"] ||
+                        [bundleId hasPrefix:@"com.apple.WindowServer"] ||
+                        [bundleId hasPrefix:@"com.apple.controlcenter"] ||
+                        [bundleId hasPrefix:@"com.apple.notificationcenterui"]) {
+                        continue;
+                    }
+                    
+                    // Convert SCWindow coordinates to match CGWindow coordinate system
+                    CGRect frame = scWindow.frame;
+                    int x = (int)frame.origin.x;
+                    int y = (int)frame.origin.y;  
+                    int width = (int)frame.size.width;
+                    int height = (int)frame.size.height;
+                    
+                    NSString *windowTitle = scWindow.title ?: @"Untitled";
+                    if ([windowTitle length] == 0) windowTitle = @"Untitled";
+                    
+                    NSDictionary *window = @{
+                        @"id": @(scWindow.windowID),
+                        @"title": windowTitle,
+                        @"appName": appName ?: @"Unknown App",
+                        @"x": @(x),
+                        @"y": @(y),
+                        @"width": @(width),
+                        @"height": @(height),
+                        @"bundleId": bundleId ?: @""
+                    };
+                    
+                    [windows addObject:window];
+                }
+            } else {
+                NSLog(@"❌ ScreenCaptureKit: Failed to get shareable content or timeout occurred");
+                // Fall back to CGWindowList as backup
+                return getAllSelectableWindowsLegacy();
+            }
+        } else {
+            NSLog(@"⚠️ ScreenCaptureKit not available, falling back to CGWindowList");
+            return getAllSelectableWindowsLegacy();
+        }
+        
+        return [windows copy];
+    }
+}
+
+// Legacy window enumeration using CGWindowList (fallback for older macOS)
+NSArray* getAllSelectableWindowsLegacy() {
     @autoreleasepool {
         NSMutableArray *windows = [NSMutableArray array];
         
@@ -734,7 +811,7 @@ bool startScreenSelection() {
         NSMutableArray *screenInfoArray = [[NSMutableArray alloc] init];
         g_screenOverlayWindows = [[NSMutableArray alloc] init];
         
-        for (NSInteger i = 0; i < [screens count]; i++) {
+        for (NSUInteger i = 0; i < [screens count]; i++) {
             NSScreen *screen = [screens objectAtIndex:i];
             NSRect screenFrame = [screen frame];
             
@@ -922,10 +999,10 @@ bool showScreenRecordingPreview(NSDictionary *screenInfo) {
         NSArray *screens = [NSScreen screens];
         if (!screens || [screens count] == 0) return false;
         
-        int selectedScreenId = [[screenInfo objectForKey:@"id"] intValue];
+        NSUInteger selectedScreenId = (NSUInteger)[[screenInfo objectForKey:@"id"] intValue];
         
         // Create overlay for each screen except the selected one
-        for (NSInteger i = 0; i < [screens count]; i++) {
+        for (NSUInteger i = 0; i < [screens count]; i++) {
             if (i == selectedScreenId) continue; // Skip selected screen
             
             NSScreen *screen = [screens objectAtIndex:i];
@@ -956,7 +1033,7 @@ bool showScreenRecordingPreview(NSDictionary *screenInfo) {
             }
         }
         
-        NSLog(@"🎬 SCREEN RECORDING PREVIEW: Showing overlay for Screen %d", selectedScreenId);
+        NSLog(@"🎬 SCREEN RECORDING PREVIEW: Showing overlay for Screen %lu", (unsigned long)selectedScreenId);
         
         return true;
         
@@ -996,7 +1073,7 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
             }
             
             // Store windows for later retrieval via getWindowSelectionStatus
-            g_allWindows = [windows mutableCopy];
+            g_allWindows = [getAllSelectableWindows() mutableCopy];
             g_isWindowSelecting = true;
             
             // Return true to indicate windows are available
@@ -1017,7 +1094,7 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
     
     @try {
         // Get all windows
-        g_allWindows = getAllSelectableWindows();
+        g_allWindows = [getAllSelectableWindows() mutableCopy];
         
         if (!g_allWindows || [g_allWindows count] == 0) {
             Napi::Error::New(env, "No selectable windows found").ThrowAsJavaScriptException();

package/test-electron-window-selector.js

@@ -0,0 +1,119 @@
+const ElectronWindowSelector = require('./electron-window-selector');
+
+// Electron environment simülasyonu
+console.log('🧪 Testing Electron Window Selector...\n');
+
+// Electron environment variable'ları set et
+process.env.ELECTRON_VERSION = '25.0.0';
+
+async function testElectronWindowSelector() {
+    const selector = new ElectronWindowSelector();
+    
+    console.log(`🔍 Environment: ${selector.isElectron ? 'Electron' : 'Node.js'}`);
+    
+    try {
+        console.log('\n1️⃣ Testing Permission Check...');
+        const permissions = await selector.checkPermissions();
+        console.log('✅ Permissions:', permissions);
+        
+        console.log('\n2️⃣ Testing Available Windows...');
+        const windows = await selector.getAvailableWindows();
+        console.log(`✅ Found ${windows.length} windows`);
+        if (windows.length > 0) {
+            console.log('   📱 Sample window:', {
+                title: windows[0].title,
+                appName: windows[0].appName,
+                size: `${windows[0].width}x${windows[0].height}`
+            });
+        }
+        
+        console.log('\n3️⃣ Testing Available Displays...');
+        const displays = await selector.getAvailableDisplays();
+        console.log(`✅ Found ${displays.length} displays`);
+        if (displays.length > 0) {
+            console.log('   🖥️ Primary display:', {
+                name: displays[0].name,
+                resolution: `${displays[0].width}x${displays[0].height}`,
+                isPrimary: displays[0].isPrimary
+            });
+        }
+        
+        console.log('\n4️⃣ Testing Window Selection (Electron Safe Mode)...');
+        const windowSelectionPromise = selector.selectWindow();
+        
+        // Event listeners
+        selector.on('windowSelected', (windowInfo) => {
+            console.log('🎯 Window selected event:', {
+                title: windowInfo.title,
+                appName: windowInfo.appName,
+                position: `${windowInfo.x},${windowInfo.y}`,
+                size: `${windowInfo.width}x${windowInfo.height}`
+            });
+        });
+        
+        selector.on('selectionStarted', () => {
+            console.log('🟢 Window selection started');
+        });
+        
+        const selectedWindow = await windowSelectionPromise;
+        console.log('✅ Window selection completed');
+        
+        console.log('\n5️⃣ Testing Screen Selection (Electron Safe Mode)...');
+        const screenSelectionPromise = selector.selectScreen();
+        
+        selector.on('screenSelected', (screenInfo) => {
+            console.log('🖥️ Screen selected event:', {
+                name: screenInfo.name || 'Display ' + screenInfo.id,
+                resolution: `${screenInfo.width}x${screenInfo.height}`,
+                isPrimary: screenInfo.isPrimary
+            });
+        });
+        
+        const selectedScreen = await screenSelectionPromise;
+        console.log('✅ Screen selection completed');
+        
+        console.log('\n6️⃣ Testing Recording Preview (Electron Safe Mode)...');
+        if (selectedWindow) {
+            await selector.showRecordingPreview(selectedWindow);
+            console.log('✅ Recording preview shown (Electron mode - no native overlay)');
+            
+            await selector.hideRecordingPreview();
+            console.log('✅ Recording preview hidden');
+        }
+        
+        console.log('\n7️⃣ Testing Screen Recording Preview (Electron Safe Mode)...');
+        if (selectedScreen) {
+            await selector.showScreenRecordingPreview(selectedScreen);
+            console.log('✅ Screen recording preview shown (Electron mode - no native overlay)');
+            
+            await selector.hideScreenRecordingPreview();
+            console.log('✅ Screen recording preview hidden');
+        }
+        
+        console.log('\n8️⃣ Cleanup...');
+        await selector.cleanup();
+        console.log('✅ Cleanup completed');
+        
+        console.log('\n🎉 All Electron Window Selector tests PASSED!');
+        
+    } catch (error) {
+        console.error('\n❌ Test failed:', error.message);
+        console.error('   Stack:', error.stack);
+        
+        // Cleanup on error
+        try {
+            await selector.cleanup();
+        } catch (cleanupError) {
+            console.error('❌ Cleanup failed:', cleanupError.message);
+        }
+    }
+}
+
+// Run test
+testElectronWindowSelector().then(() => {
+    console.log('\n✅ Test completed');
+    process.exit(0);
+}).catch((error) => {
+    console.error('\n❌ Test suite failed:', error);
+    process.exit(1);
+});

package/test-sck-availability.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+const nativeBinding = require('./build/Release/mac_recorder.node');
+
+console.log('Testing ScreenCaptureKit availability...');
+
+// Test the native functions directly
+try {
+    console.log('Native binding methods:', Object.keys(nativeBinding));
+    
+    // Check if we have the getWindows method
+    if (nativeBinding.getWindows) {
+        console.log('✅ getWindows method available');
+        const windows = nativeBinding.getWindows();
+        console.log(`Found ${windows.length} windows`);
+        
+        if (windows.length > 0) {
+            console.log('First window:', windows[0]);
+        }
+    } else {
+        console.log('❌ getWindows method not available');
+    }
+    
+} catch (error) {
+    console.error('Error:', error.message);
+}

package/test-screencapture-overlay.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+const MacRecorder = require('./index.js');
+
+async function testWindowSelector() {
+    try {
+        console.log('🧪 Testing ScreenCaptureKit-compatible window selector...');
+        
+        // Create recorder instance
+        const recorder = new MacRecorder();
+        
+        // Test if we can get windows
+        const windows = await recorder.getWindows();
+        console.log(`✅ Found ${windows.length} windows`);
+        
+        if (windows.length > 0) {
+            console.log('🔍 Sample windows:');
+            windows.slice(0, 3).forEach((win, i) => {
+                console.log(`  ${i+1}. ${win.appName || 'Unknown'} - "${win.title || 'Untitled'}" [${win.width || 0}x${win.height || 0}]`);
+                console.log(`      ID: ${win.id}, Bundle: ${win.bundleId || 'N/A'}`);
+            });
+        }
+        
+        console.log('🪟 Testing window selection overlay...');
+        
+        // Test window selection (will use ScreenCaptureKit if available)
+        const started = recorder.startWindowSelection();
+        console.log('Window selection started:', started);
+        
+        if (started) {
+            console.log('✅ Window selector started successfully with ScreenCaptureKit integration');
+            console.log('📝 Press ESC to cancel or interact with the overlay');
+            
+            // Wait a bit then cleanup
+            setTimeout(() => {
+                recorder.stopWindowSelection();
+                console.log('🧹 Window selector stopped');
+                
+                console.log('✅ Test completed successfully!');
+                console.log('🎉 ScreenCaptureKit integration is working properly');
+                process.exit(0);
+            }, 10000);
+        } else {
+            console.log('❌ Failed to start window selector');
+            process.exit(1);
+        }
+        
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+        process.exit(1);
+    }
+}
+
+testWindowSelector();

package/test-simple-windows.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const MacRecorder = require('./index.js');
+
+async function test() {
+    try {
+        const recorder = new MacRecorder();
+        console.log('Getting windows directly from native binding...');
+        
+        const nativeBinding = require('./build/Release/mac_recorder.node');
+        const nativeWindows = nativeBinding.getWindows();
+        console.log('Native windows:', nativeWindows.length);
+        if (nativeWindows.length > 0) {
+            console.log('First native window:', nativeWindows[0]);
+        }
+        
+        console.log('\nGetting windows through MacRecorder class...');
+        const windows = await recorder.getWindows();
+        console.log('MacRecorder windows:', windows.length);
+        if (windows.length > 0) {
+            console.log('First MacRecorder window:', windows[0]);
+        }
+        
+    } catch (error) {
+        console.error('Error:', error);
+    }
+}
+
+test();

package/test-window-details.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+const MacRecorder = require('./index.js');
+
+async function testWindowDetails() {
+    try {
+        const recorder = new MacRecorder();
+        const windows = await recorder.getWindows();
+        
+        console.log(`Found ${windows.length} windows:`);
+        
+        windows.forEach((win, i) => {
+            console.log(`\n${i+1}. Window ${win.id}:`);
+            console.log(`   Title: "${win.title}"`);
+            console.log(`   App: ${win.appName}`);
+            console.log(`   Bundle: ${win.bundleId}`);
+            console.log(`   Position: (${win.x}, ${win.y})`);
+            console.log(`   Size: ${win.width} x ${win.height}`);
+            if (win.bounds) {
+                console.log(`   Bounds: (${win.bounds.x}, ${win.bounds.y}) ${win.bounds.width}x${win.bounds.height}`);
+            }
+            
+            if (i >= 10) { // Limit output
+                console.log(`\n... and ${windows.length - 11} more windows`);
+                return;
+            }
+        });
+        
+    } catch (error) {
+        console.error('Error:', error.message);
+    }
+}
+
+testWindowDetails();