node-mac-recorder 2.4.7 → 2.4.9

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.7",
+	"version": "2.4.9",
 	"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;
         
@@ -974,6 +1051,42 @@ bool hideScreenRecordingPreview() {
 Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
+    // Electron safety check - prevent NSWindow crashes
+    const char* electronVersion = getenv("ELECTRON_VERSION");
+    const char* electronRunAs = getenv("ELECTRON_RUN_AS_NODE");
+    
+    NSLog(@"🔍 Debug: electronVersion='%s', electronRunAs='%s'", 
+          electronVersion ? electronVersion : "null", 
+          electronRunAs ? electronRunAs : "null");
+    
+    if (electronVersion || electronRunAs) {
+        NSLog(@"🔍 Detected Electron environment - using safe mode");
+        
+        // In Electron, return window list without creating native NSWindow overlays
+        // The Electron app can handle UI selection itself
+        @try {
+            NSArray *windows = getAllSelectableWindows();
+            
+            if (!windows || [windows count] == 0) {
+                NSLog(@"❌ No selectable windows found");
+                return Napi::Boolean::New(env, false);
+            }
+            
+            // Store windows for later retrieval via getWindowSelectionStatus
+            g_allWindows = [getAllSelectableWindows() mutableCopy];
+            g_isWindowSelecting = true;
+            
+            // Return true to indicate windows are available
+            // Electron app should call getWindowSelectionStatus to get the list
+            NSLog(@"✅ Electron-safe mode: %lu windows available for selection", (unsigned long)[windows count]);
+            return Napi::Boolean::New(env, true);
+            
+        } @catch (NSException *exception) {
+            NSLog(@"❌ Exception in Electron-safe window selection: %@", [exception reason]);
+            return Napi::Boolean::New(env, false);
+        }
+    }
+    
     if (g_isWindowSelecting) {
         NSLog(@"⚠️ Window selection already in progress");
         return Napi::Boolean::New(env, false);
@@ -981,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();
@@ -1338,6 +1451,51 @@ Napi::Value HideRecordingPreview(const Napi::CallbackInfo& info) {
 Napi::Value StartScreenSelection(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
+    // Electron safety check - prevent NSWindow crashes
+    const char* electronVersion = getenv("ELECTRON_VERSION");
+    const char* electronRunAs = getenv("ELECTRON_RUN_AS_NODE");
+    
+    NSLog(@"🔍 Screen Debug: electronVersion='%s', electronRunAs='%s'", 
+          electronVersion ? electronVersion : "null", 
+          electronRunAs ? electronRunAs : "null");
+    
+    if (electronVersion || electronRunAs) {
+        NSLog(@"🔍 Detected Electron environment - using safe screen selection");
+        
+        // In Electron, return screen list without creating native NSWindow overlays
+        @try {
+            NSArray *screens = [NSScreen screens];
+            
+            if (!screens || [screens count] == 0) {
+                NSLog(@"❌ No screens available");
+                return Napi::Boolean::New(env, false);
+            }
+            
+            // Store screens and select first one automatically for Electron
+            g_allScreens = screens;
+            g_isScreenSelecting = true;
+            
+            NSScreen *mainScreen = [screens firstObject];
+            g_selectedScreenInfo = @{
+                @"id": @((int)[screens indexOfObject:mainScreen]),
+                @"width": @((int)mainScreen.frame.size.width),
+                @"height": @((int)mainScreen.frame.size.height),
+                @"x": @((int)mainScreen.frame.origin.x),
+                @"y": @((int)mainScreen.frame.origin.y)
+            };
+            
+            // Mark as complete so getSelectedScreenInfo returns the selection
+            g_isScreenSelecting = false;
+            
+            NSLog(@"✅ Electron-safe screen selection: %lu screens available", (unsigned long)[screens count]);
+            return Napi::Boolean::New(env, true);
+            
+        } @catch (NSException *exception) {
+            NSLog(@"❌ Exception in Electron-safe screen selection: %@", [exception reason]);
+            return Napi::Boolean::New(env, false);
+        }
+    }
+    
     @try {
         bool success = startScreenSelection();
         return Napi::Boolean::New(env, success);

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

package/window-selector.js

@@ -33,13 +33,13 @@ class WindowSelector extends EventEmitter {
 		this.selectedWindow = null;
 		this.lastStatus = null;
 		
-		// Electron environment detection (for logging only)
+		// Electron environment detection
 		this.isElectron = !!(process.versions && process.versions.electron) || 
 		                 !!(process.env.ELECTRON_VERSION) ||
 		                 !!(process.env.ELECTRON_RUN_AS_NODE);
 		
 		if (this.isElectron) {
-			console.log("🔍 WindowSelector: Detected Electron environment");
+			console.log("🔍 WindowSelector: Detected Electron environment - using safe mode");
 		}
 	}
 
@@ -174,6 +174,59 @@ class WindowSelector extends EventEmitter {
 		return this.selectedWindow;
 	}
 
+	/**
+	 * Electron'da kullanmak için mevcut pencereleri döndürür
+	 * @returns {Array} Available windows for selection
+	 */
+	async getAvailableWindows() {
+		if (this.isElectron) {
+			try {
+				// Start selection to populate window list (safe mode)
+				const success = nativeBinding.startWindowSelection();
+				if (success) {
+					// Get the populated window list
+					const status = nativeBinding.getWindowSelectionStatus();
+					
+					// Stop selection immediately
+					nativeBinding.stopWindowSelection();
+					
+					// Return windows from native status
+					// In Electron safe mode, these will be available without overlay
+					const MacRecorder = require("./index.js");
+					const recorder = new MacRecorder();
+					return await recorder.getWindows();
+				}
+			} catch (error) {
+				console.error("Error getting available windows in Electron:", error.message);
+			}
+		}
+		
+		// Fallback to regular MacRecorder method
+		try {
+			const MacRecorder = require("./index.js");
+			const recorder = new MacRecorder();
+			return await recorder.getWindows();
+		} catch (error) {
+			console.error("Error getting windows:", error.message);
+			return [];
+		}
+	}
+
+	/**
+	 * Electron'da pencere seçmek için - overlay olmadan
+	 * @param {Object} windowInfo - Selected window from getAvailableWindows()
+	 */
+	selectWindowById(windowInfo) {
+		if (!windowInfo || !windowInfo.id) {
+			throw new Error("Valid window info required");
+		}
+		
+		this.selectedWindow = windowInfo;
+		this.emit('windowSelected', windowInfo);
+		
+		return windowInfo;
+	}
+
 	/**
 	 * Seçim durumunu döndürür
 	 */