node-mac-recorder 1.3.0 → 1.5.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,47 @@ if (!permissions.screenRecording) {
 
 ## 🌟 Gelişmiş Örnekler
 
+### Auto Bring-to-Front (DEFAULT - Otomatik Focus)
+```javascript
+const WindowSelector = require('./window-selector');
+
+async function autoBringToFront() {
+    const selector = new WindowSelector();
+    
+    // Auto bring-to-front varsayılan olarak AÇIK
+    // (Kapatmak için: selector.setBringToFrontEnabled(false))
+    
+    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!');
+    console.log('💡 Only the specific window focuses, not all windows of the app');
+}
+```
+
+### 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/debug-test.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+const WindowSelector = require('./window-selector');
+
+async function debugTest() {
+    console.log('🔍 Debug Window Selector Test');
+    console.log('==============================\n');
+
+    const selector = new WindowSelector();
+
+    try {
+        // İzinleri kontrol et
+        console.log('📋 Checking permissions...');
+        const permissions = await selector.checkPermissions();
+        console.log('Permissions:', JSON.stringify(permissions, null, 2));
+        
+        if (!permissions.screenRecording || !permissions.accessibility) {
+            console.log('\n❌ MISSING PERMISSIONS!');
+            console.log('Please enable in System Preferences > Security & Privacy:');
+            console.log('   ✓ Screen Recording - Add Terminal/your IDE');
+            console.log('   ✓ Accessibility - Add Terminal/your IDE');
+            console.log('\nAfter enabling permissions, restart this test.');
+            return;
+        }
+
+        console.log('✅ Permissions OK\n');
+
+        // Debug mode ile başlat
+        console.log('🚀 Starting selection with debug info...');
+        await selector.startSelection();
+        
+        let windowCount = 0;
+
+        selector.on('windowEntered', (window) => {
+            windowCount++;
+            console.log(`\n[${windowCount}] 🎯 WINDOW DETECTED:`);
+            console.log(`    App: ${window.appName}`);
+            console.log(`    Title: "${window.title}"`);
+            console.log(`    ID: ${window.id}`);
+            console.log(`    Position: (${window.x}, ${window.y})`);
+            console.log(`    Size: ${window.width} × ${window.height}`);
+            console.log(`    🔝 Should auto-focus now...`);
+        });
+
+        selector.on('windowLeft', (window) => {
+            console.log(`\n🚪 LEFT WINDOW: ${window.appName} - "${window.title}"`);
+        });
+
+        selector.on('error', (error) => {
+            console.error('\n❌ ERROR:', error.message);
+        });
+
+        console.log('📋 Test Instructions:');
+        console.log('   1. Move cursor over different application windows');
+        console.log('   2. You should see:');
+        console.log('      - Blue overlay rectangle around windows');
+        console.log('      - "Select Window" button in center');
+        console.log('      - Windows automatically coming to front');
+        console.log('   3. If overlay not visible, check permissions');
+        console.log('   4. Press Ctrl+C to exit\n');
+        console.log('🖱️  START MOVING CURSOR NOW...\n');
+
+        // Status monitoring
+        let statusCount = 0;
+        setInterval(() => {
+            statusCount++;
+            const status = selector.getStatus();
+            
+            if (statusCount % 50 === 0) { // Every 5 seconds
+                console.log(`⏱️  Status Check #${statusCount/50}:`);
+                console.log(`   - Selecting: ${status.isSelecting}`);
+                console.log(`   - Windows found: ${status.nativeStatus?.windowCount || 0}`);
+                console.log(`   - Overlay active: ${status.nativeStatus?.hasOverlay || false}`);
+                if (status.nativeStatus?.currentWindow) {
+                    console.log(`   - Current: ${status.nativeStatus.currentWindow.appName}`);
+                }
+                console.log('');
+            }
+        }, 100);
+
+    } catch (error) {
+        console.error('❌ Fatal Error:', error.message);
+        console.error(error.stack);
+    }
+}
+
+// Handle Ctrl+C gracefully
+process.on('SIGINT', async () => {
+    console.log('\n\n🛑 Stopping debug test...');
+    process.exit(0);
+});
+
+if (require.main === module) {
+    debugTest();
+}

package/default-auto-front-test.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+const WindowSelector = require('./window-selector');
+
+async function testDefaultAutoBringToFront() {
+    console.log('🔝 Default Auto Bring-To-Front Test');
+    console.log('====================================\n');
+
+    const selector = new WindowSelector();
+
+    try {
+        console.log('🚀 Starting window selector with DEFAULT auto bring-to-front...');
+        console.log('(Auto bring-to-front is now enabled by default)\n');
+        
+        console.log('📋 Instructions:');
+        console.log('   • Move cursor over different windows');
+        console.log('   • Each window should automatically come to front');
+        console.log('   • Only the specific window should focus (not whole app)');
+        console.log('   • Press D to disable auto mode');
+        console.log('   • Press E to re-enable auto mode');
+        console.log('   • Press Ctrl+C to exit\n');
+
+        let windowCount = 0;
+        let lastWindowId = null;
+
+        selector.on('windowEntered', (window) => {
+            if (window.id !== lastWindowId) {
+                windowCount++;
+                console.log(`[${windowCount}] 🎯 WINDOW: ${window.appName} - "${window.title}"`);
+                console.log(`    📍 Position: (${window.x}, ${window.y})`);
+                console.log(`    📏 Size: ${window.width} × ${window.height}`);
+                console.log(`    🔝 Should auto-focus THIS specific window only!`);
+                lastWindowId = window.id;
+            }
+        });
+
+        selector.on('windowLeft', (window) => {
+            console.log(`🚪 Left: ${window.appName} - "${window.title}"\n`);
+        });
+
+        // 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 === 'd') {
+                console.log('\n🔄 Disabling auto bring-to-front...');
+                selector.setBringToFrontEnabled(false);
+                console.log('   ✅ Auto mode OFF - Windows will not auto-focus');
+            } else if (key.name === 'e') {
+                console.log('\n🔄 Enabling auto bring-to-front...');
+                selector.setBringToFrontEnabled(true);
+                console.log('   ✅ Auto mode ON - Windows will auto-focus again');
+            } else if (key.ctrl && key.name === 'c') {
+                console.log('\n\n🛑 Stopping...');
+                console.log(`📊 Total windows encountered: ${windowCount}`);
+                await selector.cleanup();
+                process.exit(0);
+            }
+        });
+
+        await selector.startSelection();
+
+        // Status update every 10 seconds
+        setInterval(() => {
+            console.log(`\n⏱️  Status: ${windowCount} windows encountered so far`);
+            console.log('   (Continue moving cursor over windows to test auto-focus)');
+        }, 10000);
+
+        // Keep running
+        setInterval(() => {}, 1000);
+
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+        console.error(error.stack);
+    } finally {
+        await selector.cleanup();
+    }
+}
+
+if (require.main === module) {
+    testDefaultAutoBringToFront();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "1.3.0",
+	"version": "1.5.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
@@ -33,8 +35,8 @@ NSArray* getAllSelectableWindows();
     self = [super initWithFrame:frameRect];
     if (self) {
         self.wantsLayer = YES;
-        self.layer.backgroundColor = [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.5] CGColor];
-        self.layer.borderColor = [[NSColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:0.9] CGColor];
+        self.layer.backgroundColor = [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.6] CGColor];
+        self.layer.borderColor = [[NSColor colorWithRed:0.0 green:0.4 blue:0.8 alpha:0.9] CGColor];
         self.layer.borderWidth = 5.0;
         self.layer.cornerRadius = 8.0;
     }
@@ -47,11 +49,11 @@ NSArray* getAllSelectableWindows();
     if (!self.windowInfo) return;
     
     // Background with transparency
-    [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.5] setFill];
+    [[NSColor colorWithRed:0.0 green:0.5 blue:1.0 alpha:0.6] setFill];
     NSRectFill(dirtyRect);
     
     // Border
-    [[NSColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:0.9] setStroke];
+    [[NSColor colorWithRed:0.0 green:0.4 blue:0.8 alpha:0.9] setStroke];
     NSBezierPath *border = [NSBezierPath bezierPathWithRoundedRect:self.bounds xRadius:8 yRadius:8];
     [border setLineWidth:3.0];
     [border stroke];
@@ -65,14 +67,14 @@ NSArray* getAllSelectableWindows();
     [style setAlignment:NSTextAlignmentCenter];
     
     NSDictionary *attributes = @{
-        NSFontAttributeName: [NSFont systemFontOfSize:14 weight:NSFontWeightMedium],
+        NSFontAttributeName: [NSFont systemFontOfSize:21 weight:NSFontWeightMedium],
         NSForegroundColorAttributeName: [NSColor whiteColor],
         NSParagraphStyleAttributeName: style,
         NSStrokeColorAttributeName: [NSColor blackColor],
         NSStrokeWidthAttributeName: @(-2.0)
     };
     
-    NSRect textRect = NSMakeRect(10, self.bounds.size.height - 60, self.bounds.size.width - 20, 50);
+    NSRect textRect = NSMakeRect(10, self.bounds.size.height - 90, self.bounds.size.width - 20, 80);
     [infoText drawInRect:textRect withAttributes:attributes];
 }
 
@@ -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
@@ -326,12 +445,26 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
         g_overlayView = [[WindowSelectorOverlayView alloc] initWithFrame:initialFrame];
         [g_overlayWindow setContentView:g_overlayView];
         
-        // Create select button
-        g_selectButton = [[NSButton alloc] initWithFrame:NSMakeRect(0, 0, 120, 40)];
+        // Create select button with blue theme
+        g_selectButton = [[NSButton alloc] initWithFrame:NSMakeRect(0, 0, 140, 50)];
         [g_selectButton setTitle:@"Select Window"];
         [g_selectButton setButtonType:NSButtonTypeMomentaryPushIn];
         [g_selectButton setBezelStyle:NSBezelStyleRounded];
-        [g_selectButton setFont:[NSFont systemFontOfSize:14 weight:NSFontWeightMedium]];
+        [g_selectButton setFont:[NSFont systemFontOfSize:16 weight:NSFontWeightSemibold]];
+        
+        // Blue themed button styling
+        [g_selectButton setWantsLayer:YES];
+        [g_selectButton.layer setBackgroundColor:[[NSColor colorWithRed:0.0 green:0.4 blue:0.8 alpha:0.9] CGColor]];
+        [g_selectButton.layer setCornerRadius:8.0];
+        [g_selectButton.layer setBorderColor:[[NSColor colorWithRed:0.0 green:0.3 blue:0.7 alpha:1.0] CGColor]];
+        [g_selectButton.layer setBorderWidth:2.0];
+        [g_selectButton setContentTintColor:[NSColor whiteColor]];
+        
+        // Add shadow for better visibility
+        [g_selectButton.layer setShadowColor:[[NSColor blackColor] CGColor]];
+        [g_selectButton.layer setShadowOffset:NSMakeSize(0, -2)];
+        [g_selectButton.layer setShadowRadius:4.0];
+        [g_selectButton.layer setShadowOpacity:0.3];
         
         // Create delegate for button action and timer
         g_delegate = [[WindowSelectorDelegate alloc] init];
@@ -441,6 +574,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 +647,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,41 @@ 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);
+			// Only log if explicitly setting, not on startup
+			if (arguments.length > 0) {
+				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
 	 */