node-mac-recorder 1.3.0 → 1.4.0

package/WINDOW_SELECTOR_README.md

@@ -12,6 +12,8 @@ Bu modül, macOS'ta sistem imleci ile pencere seçimi yapabilmenizi sağlayan g
 - **Multi-display Support**: Çoklu ekran kurulumlarında çalışır
 - **Detailed Window Info**: Pencere pozisyonu, boyutu ve hangi ekranda olduğunu döndürür
 - **Event-driven API**: Pencere hover, seçim ve hata durumları için event'ler
+- **Window Focus Control**: Detect edilen pencereyi otomatik olarak en öne getirir
+- **Auto Bring-to-Front**: Cursor hangi pencereye gelirse otomatik focus yapar
 - **Permission Management**: macOS izin kontrolü ve yönetimi
 
 ## 🚀 Kurulum
@@ -150,6 +152,29 @@ macOS izinlerini kontrol eder.
 
 **Returns:** `Promise<PermissionStatus>`
 
+##### `async bringWindowToFront(windowId)`
+Belirtilen pencereyi en öne getirir (focus yapar).
+
+**Parameters:**
+- `windowId` (number) - Window ID
+
+**Returns:** `Promise<boolean>` - Başarı/başarısızlık
+
+```javascript
+const success = await selector.bringWindowToFront(windowInfo.id);
+```
+
+##### `setBringToFrontEnabled(enabled)`
+Otomatik pencere en öne getirme özelliğini aktif/pasif yapar.
+
+**Parameters:**
+- `enabled` (boolean) - Enable/disable
+
+```javascript
+selector.setBringToFrontEnabled(true);  // Auto mode ON
+selector.setBringToFrontEnabled(false); // Auto mode OFF
+```
+
 ##### `async cleanup()`
 Tüm kaynakları temizler ve seçimi durdurur.
 
@@ -309,6 +334,46 @@ if (!permissions.screenRecording) {
 
 ## 🌟 Gelişmiş Örnekler
 
+### Auto Bring-to-Front (Otomatik Focus)
+```javascript
+const WindowSelector = require('./window-selector');
+
+async function autoBringToFront() {
+    const selector = new WindowSelector();
+    
+    // Otomatik focus modunu aktif et
+    selector.setBringToFrontEnabled(true);
+    
+    selector.on('windowEntered', (window) => {
+        console.log(`🔝 Auto-focused: ${window.appName} - "${window.title}"`);
+    });
+    
+    await selector.startSelection();
+    console.log('🖱️ Move cursor over windows - they will come to front automatically!');
+}
+```
+
+### Manuel Window Focus
+```javascript
+const WindowSelector = require('./window-selector');
+
+async function manualFocus() {
+    const selector = new WindowSelector();
+    
+    selector.on('windowEntered', async (window) => {
+        console.log(`Found: ${window.appName} - "${window.title}"`);
+        
+        // Manuel olarak pencereyi en öne getir
+        const success = await selector.bringWindowToFront(window.id);
+        if (success) {
+            console.log('✅ Window brought to front!');
+        }
+    });
+    
+    await selector.startSelection();
+}
+```
+
 ### Otomatik Pencere Kaydı
 ```javascript
 const WindowSelector = require('./window-selector');

package/auto-front-demo.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+const WindowSelector = require('./window-selector');
+
+async function autoBringToFrontDemo() {
+    console.log('🤖 Auto Bring-To-Front Demo');
+    console.log('============================\n');
+
+    const selector = new WindowSelector();
+
+    try {
+        console.log('🔄 Enabling auto bring-to-front feature...');
+        selector.setBringToFrontEnabled(true);
+
+        console.log('✅ Auto mode enabled!');
+        console.log('🖱️  Now move your cursor over different windows');
+        console.log('🔝 Each window should automatically come to front\n');
+
+        let windowCount = 0;
+        let lastWindowId = null;
+
+        selector.on('windowEntered', (window) => {
+            if (window.id !== lastWindowId) {
+                windowCount++;
+                console.log(`[${windowCount}] 🎯 AUTO-FRONT: ${window.appName} - "${window.title}"`);
+                console.log(`    📍 Position: (${window.x}, ${window.y})`);
+                console.log(`    📏 Size: ${window.width} × ${window.height}`);
+                console.log(`    🔝 Window should come to front automatically!\n`);
+                lastWindowId = window.id;
+            }
+        });
+
+        selector.on('windowLeft', (window) => {
+            console.log(`🚪 Left: ${window.appName} - "${window.title}"\n`);
+        });
+
+        await selector.startSelection();
+
+        console.log('Demo started! Move cursor over different app windows to see them come to front.');
+        console.log('Press Ctrl+C to stop\n');
+
+        // Auto-stop after 60 seconds
+        setTimeout(async () => {
+            console.log('\n⏰ Demo completed!');
+            console.log(`📊 Total windows auto-focused: ${windowCount}`);
+            selector.setBringToFrontEnabled(false);
+            await selector.cleanup();
+            process.exit(0);
+        }, 60000);
+
+        // Manual stop
+        process.on('SIGINT', async () => {
+            console.log('\n\n🛑 Stopping demo...');
+            console.log(`📊 Total windows auto-focused: ${windowCount}`);
+            selector.setBringToFrontEnabled(false);
+            await selector.cleanup();
+            process.exit(0);
+        });
+
+        // Prevent exit
+        setInterval(() => {}, 1000);
+
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+        await selector.cleanup();
+    }
+}
+
+if (require.main === module) {
+    autoBringToFrontDemo();
+}

package/bring-to-front-test.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+const WindowSelector = require('./window-selector');
+
+async function testBringToFront() {
+    console.log('🔝 Bring To Front Test');
+    console.log('======================\n');
+
+    const selector = new WindowSelector();
+
+    try {
+        // Test 1: Manual bring to front
+        console.log('📋 Test 1: Manual window bring-to-front');
+        console.log('Move cursor over a window and press SPACE to bring it to front\n');
+
+        let currentWindow = null;
+
+        selector.on('windowEntered', (window) => {
+            currentWindow = window;
+            console.log(`\n🏠 Window: ${window.appName} - "${window.title}" (ID: ${window.id})`);
+            console.log('   📍 Position:', `(${window.x}, ${window.y})`);
+            console.log('   📏 Size:', `${window.width} × ${window.height}`);
+            console.log('   💡 Press SPACE to bring this window to front');
+            console.log('   💡 Press A to enable AUTO bring-to-front');
+            console.log('   💡 Press D to disable AUTO bring-to-front');
+        });
+
+        selector.on('windowLeft', (window) => {
+            console.log(`🚪 Left: ${window.appName} - "${window.title}"`);
+            currentWindow = null;
+        });
+
+        // Keyboard controls
+        const readline = require('readline');
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+
+        process.stdin.on('keypress', async (str, key) => {
+            if (key.name === 'space' && currentWindow) {
+                console.log(`\n🔝 Bringing window to front: ${currentWindow.appName} - "${currentWindow.title}"`);
+                try {
+                    const success = await selector.bringWindowToFront(currentWindow.id);
+                    if (success) {
+                        console.log('   ✅ Window brought to front successfully!');
+                    } else {
+                        console.log('   ❌ Failed to bring window to front');
+                    }
+                } catch (error) {
+                    console.log('   ❌ Error:', error.message);
+                }
+            } else if (key.name === 'a') {
+                console.log('\n🔄 Enabling AUTO bring-to-front mode...');
+                selector.setBringToFrontEnabled(true);
+                console.log('   ✅ Auto mode ON - Windows will come to front automatically');
+            } else if (key.name === 'd') {
+                console.log('\n🔄 Disabling AUTO bring-to-front mode...');
+                selector.setBringToFrontEnabled(false);
+                console.log('   ✅ Auto mode OFF - Manual control only');
+            } else if (key.ctrl && key.name === 'c') {
+                process.exit(0);
+            }
+        });
+
+        console.log('🚀 Starting window selection...\n');
+        console.log('📋 Controls:');
+        console.log('   SPACE     - Bring current window to front');
+        console.log('   A         - Enable AUTO bring-to-front');
+        console.log('   D         - Disable AUTO bring-to-front');
+        console.log('   Ctrl+C    - Exit\n');
+
+        await selector.startSelection();
+
+        // Keep running
+        process.on('SIGINT', async () => {
+            console.log('\n🛑 Stopping...');
+            await selector.cleanup();
+            process.exit(0);
+        });
+
+        // Prevent exit
+        setInterval(() => {}, 1000);
+
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+        console.error(error.stack);
+    } finally {
+        // Cleanup
+        await selector.cleanup();
+    }
+}
+
+async function testAutoBringToFront() {
+    console.log('🤖 Auto Bring To Front Test');
+    console.log('============================\n');
+
+    const selector = new WindowSelector();
+
+    try {
+        // Enable auto bring-to-front
+        console.log('🔄 Enabling auto bring-to-front...');
+        selector.setBringToFrontEnabled(true);
+
+        let windowCount = 0;
+
+        selector.on('windowEntered', (window) => {
+            windowCount++;
+            console.log(`\n[${windowCount}] 🔝 AUTO FRONT: ${window.appName} - "${window.title}"`);
+            console.log(`    📍 Position: (${window.x}, ${window.y})`);
+            console.log(`    📏 Size: ${window.width} × ${window.height}`);
+            console.log('    🚀 Window should automatically come to front!');
+        });
+
+        console.log('✅ Auto bring-to-front enabled');
+        console.log('🖱️  Move cursor over different windows');
+        console.log('🔝 Each window should automatically come to front');
+        console.log('⏱️  Test will run for 30 seconds\n');
+
+        await selector.startSelection();
+
+        // Auto-stop after 30 seconds
+        setTimeout(async () => {
+            console.log('\n⏰ Test completed!');
+            console.log(`📊 Total windows auto-focused: ${windowCount}`);
+            selector.setBringToFrontEnabled(false);
+            await selector.cleanup();
+            process.exit(0);
+        }, 30000);
+
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+        await selector.cleanup();
+    }
+}
+
+// Main function
+async function main() {
+    const args = process.argv.slice(2);
+    
+    if (args.includes('--auto')) {
+        await testAutoBringToFront();
+    } else if (args.includes('--help')) {
+        console.log('Bring To Front Tests:');
+        console.log('====================');
+        console.log('node bring-to-front-test.js [option]');
+        console.log('');
+        console.log('Options:');
+        console.log('  --manual    Manual bring-to-front test (default)');
+        console.log('  --auto      Auto bring-to-front test');
+        console.log('  --help      Show this help');
+    } else {
+        await testBringToFront();
+    }
+}
+
+if (require.main === module) {
+    main().catch(console.error);
+}

package/package.json

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

package/src/window_selector.mm

@@ -15,12 +15,14 @@ static NSTimer *g_trackingTimer = nil;
 static NSDictionary *g_selectedWindowInfo = nil;
 static NSMutableArray *g_allWindows = nil;
 static NSDictionary *g_currentWindowUnderCursor = nil;
+static bool g_bringToFrontEnabled = true; // Default enabled
 
 // Forward declarations
 void cleanupWindowSelector();
 void updateOverlay();
 NSDictionary* getWindowUnderCursor(CGPoint point);
 NSArray* getAllSelectableWindows();
+bool bringWindowToFront(int windowId);
 
 // Custom overlay view class
 @interface WindowSelectorOverlayView : NSView
@@ -99,6 +101,112 @@ NSArray* getAllSelectableWindows();
 
 static WindowSelectorDelegate *g_delegate = nil;
 
+// Bring window to front using Accessibility API
+bool bringWindowToFront(int windowId) {
+    @autoreleasepool {
+        @try {
+            // Method 1: Using Accessibility API (most reliable)
+            AXUIElementRef systemWide = AXUIElementCreateSystemWide();
+            if (!systemWide) return false;
+            
+            CFArrayRef windowList = NULL;
+            AXError error = AXUIElementCopyAttributeValue(systemWide, kAXWindowsAttribute, (CFTypeRef*)&windowList);
+            
+            if (error == kAXErrorSuccess && windowList) {
+                CFIndex windowCount = CFArrayGetCount(windowList);
+                
+                for (CFIndex i = 0; i < windowCount; i++) {
+                    AXUIElementRef windowElement = (AXUIElementRef)CFArrayGetValueAtIndex(windowList, i);
+                    
+                    // Get window ID by comparing with CGWindowList
+                    // Since _AXUIElementGetWindow is not available, we'll use app PID approach
+                    pid_t windowPid;
+                    error = AXUIElementGetPid(windowElement, &windowPid);
+                    
+                    if (error == kAXErrorSuccess) {
+                        // Get window info for this PID from CGWindowList
+                        CFArrayRef cgWindowList = CGWindowListCopyWindowInfo(kCGWindowListOptionAll, kCGNullWindowID);
+                        if (cgWindowList) {
+                            NSArray *windowArray = (__bridge NSArray *)cgWindowList;
+                            
+                            for (NSDictionary *windowInfo in windowArray) {
+                                NSNumber *cgWindowId = [windowInfo objectForKey:(NSString *)kCGWindowNumber];
+                                NSNumber *processId = [windowInfo objectForKey:(NSString *)kCGWindowOwnerPID];
+                                
+                                if ([cgWindowId intValue] == windowId && [processId intValue] == windowPid) {
+                                    // Found the window, bring it to front
+                                    NSLog(@"🔝 BRINGING TO FRONT: Window ID %d (PID: %d)", windowId, windowPid);
+                                    
+                                    // Method 1: Raise specific window (not the whole app)
+                                    error = AXUIElementPerformAction(windowElement, kAXRaiseAction);
+                                    if (error == kAXErrorSuccess) {
+                                        NSLog(@"   ✅ Specific window raised successfully");
+                                    } else {
+                                        NSLog(@"   ⚠️ Raise action failed: %d", error);
+                                    }
+                                    
+                                    // Method 2: Focus specific window (not main window)
+                                    error = AXUIElementSetAttributeValue(windowElement, kAXFocusedAttribute, kCFBooleanTrue);
+                                    if (error == kAXErrorSuccess) {
+                                        NSLog(@"   ✅ Specific window focused");
+                                    } else {
+                                        NSLog(@"   ⚠️ Focus failed: %d", error);
+                                    }
+                                    
+                                    CFRelease(cgWindowList);
+                                    CFRelease(windowList);
+                                    CFRelease(systemWide);
+                                    return true;
+                                }
+                            }
+                            CFRelease(cgWindowList);
+                        }
+                    }
+                }
+                CFRelease(windowList);
+            }
+            
+            CFRelease(systemWide);
+            
+            // Method 2: Light activation fallback (minimal app activation)
+            NSLog(@"   🔄 Trying minimal activation for window %d", windowId);
+            
+            // Get window info to find the process
+            CFArrayRef cgWindowList = CGWindowListCopyWindowInfo(kCGWindowListOptionAll, kCGNullWindowID);
+            if (cgWindowList) {
+                NSArray *windowArray = (__bridge NSArray *)cgWindowList;
+                
+                for (NSDictionary *windowInfo in windowArray) {
+                    NSNumber *cgWindowId = [windowInfo objectForKey:(NSString *)kCGWindowNumber];
+                    if ([cgWindowId intValue] == windowId) {
+                        // Get process ID
+                        NSNumber *processId = [windowInfo objectForKey:(NSString *)kCGWindowOwnerPID];
+                        if (processId) {
+                            // Light activation - only bring app to front, don't activate all windows
+                            NSRunningApplication *app = [NSRunningApplication runningApplicationWithProcessIdentifier:[processId intValue]];
+                            if (app) {
+                                // Use NSApplicationActivateIgnoringOtherApps only (no NSApplicationActivateAllWindows)
+                                [app activateWithOptions:NSApplicationActivateIgnoringOtherApps];
+                                NSLog(@"   ✅ App minimally activated: PID %d (specific window should be frontmost)", [processId intValue]);
+                                CFRelease(cgWindowList);
+                                return true;
+                            }
+                        }
+                        break;
+                    }
+                }
+                CFRelease(cgWindowList);
+            }
+            
+            return false;
+            
+        } @catch (NSException *exception) {
+            NSLog(@"❌ Error bringing window to front: %@", exception);
+            return false;
+        }
+    }
+}
+
 // Get all selectable windows
 NSArray* getAllSelectableWindows() {
     @autoreleasepool {
@@ -216,6 +324,17 @@ void updateOverlay() {
                   overlayFrame.origin.x, overlayFrame.origin.y, 
                   overlayFrame.size.width, overlayFrame.size.height,
                   [g_overlayWindow level]);
+            
+            // Bring window to front if enabled
+            if (g_bringToFrontEnabled) {
+                int windowId = [[windowUnderCursor objectForKey:@"id"] intValue];
+                if (windowId > 0) {
+                    bool success = bringWindowToFront(windowId);
+                    if (!success) {
+                        NSLog(@"   ⚠️ Failed to bring window to front");
+                    }
+                }
+            }
             [g_overlayWindow setFrame:overlayFrame display:YES];
             
             // Update overlay view window info
@@ -441,6 +560,43 @@ Napi::Value GetSelectedWindowInfo(const Napi::CallbackInfo& info) {
     }
 }
 
+// NAPI Function: Bring Window To Front
+Napi::Value BringWindowToFront(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Window ID required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    int windowId = info[0].As<Napi::Number>().Int32Value();
+    
+    @try {
+        bool success = bringWindowToFront(windowId);
+        return Napi::Boolean::New(env, success);
+        
+    } @catch (NSException *exception) {
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// NAPI Function: Enable/Disable Auto Bring To Front
+Napi::Value SetBringToFrontEnabled(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Boolean value required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    bool enabled = info[0].As<Napi::Boolean>();
+    g_bringToFrontEnabled = enabled;
+    
+    NSLog(@"🔄 Auto bring-to-front: %s", enabled ? "ENABLED" : "DISABLED");
+    
+    return Napi::Boolean::New(env, true);
+}
+
 // NAPI Function: Get Window Selection Status
 Napi::Value GetWindowSelectionStatus(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -477,6 +633,8 @@ Napi::Object InitWindowSelector(Napi::Env env, Napi::Object exports) {
     exports.Set("stopWindowSelection", Napi::Function::New(env, StopWindowSelection));
     exports.Set("getSelectedWindowInfo", Napi::Function::New(env, GetSelectedWindowInfo));
     exports.Set("getWindowSelectionStatus", Napi::Function::New(env, GetWindowSelectionStatus));
+    exports.Set("bringWindowToFront", Napi::Function::New(env, BringWindowToFront));
+    exports.Set("setBringToFrontEnabled", Napi::Function::New(env, SetBringToFrontEnabled));
     
     return exports;
 }

package/window-selector.js

@@ -214,6 +214,38 @@ class WindowSelector extends EventEmitter {
 		});
 	}
 
+	/**
+	 * Pencereyi en öne getirir (focus yapar)
+	 * @param {number} windowId - Window ID
+	 * @returns {Promise<boolean>} Success/failure
+	 */
+	async bringWindowToFront(windowId) {
+		if (!windowId) {
+			throw new Error("Window ID is required");
+		}
+
+		try {
+			const success = nativeBinding.bringWindowToFront(windowId);
+			return success;
+		} catch (error) {
+			throw new Error(`Failed to bring window to front: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Otomatik pencere en öne getirme özelliğini aktif/pasif yapar
+	 * Cursor hangi pencereye gelirse otomatik olarak en öne getirir
+	 * @param {boolean} enabled - Enable/disable auto bring to front
+	 */
+	setBringToFrontEnabled(enabled) {
+		try {
+			nativeBinding.setBringToFrontEnabled(enabled);
+			console.log(`🔄 Auto bring-to-front: ${enabled ? 'ENABLED' : 'DISABLED'}`);
+		} catch (error) {
+			throw new Error(`Failed to set bring to front: ${error.message}`);
+		}
+	}
+
 	/**
 	 * Cleanup - tüm kaynakları temizle
 	 */