node-mac-recorder 1.2.11 → 1.4.0

package/window-selector-test.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+const WindowSelector = require('./window-selector');
+const readline = require('readline');
+
+async function main() {
+    console.log('🔍 Window Selector Test');
+    console.log('=======================\n');
+
+    const selector = new WindowSelector();
+
+    try {
+        // Permissions kontrolü
+        console.log('1️⃣ Checking permissions...');
+        const permissions = await selector.checkPermissions();
+        console.log('Permissions:', permissions);
+        
+        if (!permissions.screenRecording || !permissions.accessibility) {
+            console.warn('⚠️ Warning: Some permissions missing. Go to System Preferences > Security & Privacy');
+            console.warn('   - Privacy > Screen Recording: Enable for Terminal/Node');
+            console.warn('   - Privacy > Accessibility: Enable for Terminal/Node');
+            console.log();
+        }
+
+        // Event listener'ları ayarla
+        selector.on('selectionStarted', () => {
+            console.log('✅ Window selection started');
+            console.log('🖱️ Move your cursor over windows to highlight them');
+            console.log('🎯 Click "Select Window" button to choose a window');
+            console.log('❌ Press Ctrl+C to cancel\n');
+        });
+
+        selector.on('windowEntered', (window) => {
+            console.log(`🏠 Entered window: "${window.title}" - ${window.appName}`);
+        });
+
+        selector.on('windowLeft', (window) => {
+            console.log(`🚪 Left window: "${window.title}" - ${window.appName}`);
+        });
+
+        selector.on('windowSelected', (windowInfo) => {
+            console.log('\n🎉 Window Selected!');
+            console.log('==================');
+            console.log(`Title: "${windowInfo.title}"`);
+            console.log(`Application: ${windowInfo.appName}`);
+            console.log(`Position: (${windowInfo.x}, ${windowInfo.y})`);
+            console.log(`Size: ${windowInfo.width} x ${windowInfo.height}`);
+            console.log(`Screen ID: ${windowInfo.screenId}`);
+            console.log(`Screen Position: (${windowInfo.screenX}, ${windowInfo.screenY})`);
+            console.log(`Screen Size: ${windowInfo.screenWidth} x ${windowInfo.screenHeight}`);
+        });
+
+        selector.on('selectionStopped', () => {
+            console.log('🛑 Window selection stopped');
+        });
+
+        selector.on('error', (error) => {
+            console.error('❌ Error:', error.message);
+        });
+
+        // Ctrl+C handler
+        process.on('SIGINT', async () => {
+            console.log('\n\n🛑 Stopping window selection...');
+            await selector.cleanup();
+            process.exit(0);
+        });
+
+        console.log('2️⃣ Testing window selection...\n');
+
+        // Seçim başlat
+        const selectedWindow = await selector.selectWindow();
+        
+        if (selectedWindow) {
+            console.log('\n✨ Final result:');
+            console.log(JSON.stringify(selectedWindow, null, 2));
+            
+            // Ek bilgiler
+            console.log('\n📊 Additional Analysis:');
+            console.log(`Window area: ${selectedWindow.width * selectedWindow.height} pixels`);
+            console.log(`Aspect ratio: ${(selectedWindow.width / selectedWindow.height).toFixed(2)}`);
+            
+            // Window bounds relative to screen
+            const relativeX = selectedWindow.x - selectedWindow.screenX;
+            const relativeY = selectedWindow.y - selectedWindow.screenY;
+            console.log(`Relative position on screen: (${relativeX}, ${relativeY})`);
+            
+            if (relativeX < 0 || relativeY < 0 || 
+                relativeX + selectedWindow.width > selectedWindow.screenWidth ||
+                relativeY + selectedWindow.height > selectedWindow.screenHeight) {
+                console.log('⚠️  Window extends beyond screen boundaries (multi-monitor setup)');
+            } else {
+                console.log('✅ Window is fully contained within its screen');
+            }
+        }
+
+    } catch (error) {
+        console.error('❌ Test failed:', error.message);
+        console.error(error.stack);
+    } finally {
+        await selector.cleanup();
+        console.log('\n🧹 Cleanup completed');
+        process.exit(0);
+    }
+}
+
+// Alternative test function for programmatic testing
+async function testWindowSelectorAPI() {
+    console.log('🧪 API Test Mode');
+    console.log('===============\n');
+
+    const selector = new WindowSelector();
+
+    try {
+        // Test 1: Status before selection
+        console.log('Test 1: Initial status');
+        const initialStatus = selector.getStatus();
+        console.log('Initial status:', initialStatus);
+        console.assert(!initialStatus.isSelecting, 'Should not be selecting initially');
+        console.assert(!initialStatus.hasSelectedWindow, 'Should not have selected window initially');
+        console.log('✅ Initial status test passed\n');
+
+        // Test 2: Start selection
+        console.log('Test 2: Start selection');
+        await selector.startSelection();
+        const selectingStatus = selector.getStatus();
+        console.log('Selecting status:', selectingStatus);
+        console.assert(selectingStatus.isSelecting, 'Should be selecting after start');
+        console.log('✅ Start selection test passed\n');
+
+        // Wait a bit to let user move cursor
+        console.log('Move your cursor over different windows for 3 seconds...');
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
+        // Test 3: Stop selection
+        console.log('Test 3: Stop selection');
+        await selector.stopSelection();
+        const stoppedStatus = selector.getStatus();
+        console.log('Stopped status:', stoppedStatus);
+        console.assert(!stoppedStatus.isSelecting, 'Should not be selecting after stop');
+        console.log('✅ Stop selection test passed\n');
+
+        console.log('🎉 All API tests passed!');
+
+    } catch (error) {
+        console.error('❌ API test failed:', error.message);
+        throw error;
+    } finally {
+        await selector.cleanup();
+    }
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const testMode = args.includes('--api-test') ? 'api' : 'interactive';
+
+if (testMode === 'api') {
+    testWindowSelectorAPI().catch(console.error);
+} else {
+    main().catch(console.error);
+}

package/window-selector.js

@@ -0,0 +1,291 @@
+const { EventEmitter } = require("events");
+const path = require("path");
+
+// Native modülü yükle
+let nativeBinding;
+try {
+	nativeBinding = require("./build/Release/mac_recorder.node");
+} catch (error) {
+	try {
+		nativeBinding = require("./build/Debug/mac_recorder.node");
+	} catch (debugError) {
+		throw new Error(
+			'Native module not found. Please run "npm run build" to compile the native module.\n' +
+				"Original error: " +
+				error.message
+		);
+	}
+}
+
+class WindowSelector extends EventEmitter {
+	constructor() {
+		super();
+		this.isSelecting = false;
+		this.selectionTimer = null;
+		this.selectedWindow = null;
+		this.lastStatus = null;
+	}
+
+	/**
+	 * Pencere seçim modunu başlatır
+	 * İmleç hangi pencerenin üstüne gelirse o pencereyi highlight eder
+	 * Select butonuna basılınca seçim tamamlanır
+	 */
+	async startSelection() {
+		if (this.isSelecting) {
+			throw new Error("Window selection is already in progress");
+		}
+
+		return new Promise((resolve, reject) => {
+			try {
+				// Native window selection başlat
+				const success = nativeBinding.startWindowSelection();
+				
+				if (success) {
+					this.isSelecting = true;
+					this.selectedWindow = null;
+					
+					// Status polling timer başlat (higher frequency for overlay updates)
+					this.selectionTimer = setInterval(() => {
+						this.checkSelectionStatus();
+					}, 50); // 20 FPS status check for smooth overlay
+
+					this.emit("selectionStarted");
+					resolve(true);
+				} else {
+					reject(new Error("Failed to start window selection"));
+				}
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+
+	/**
+	 * Pencere seçim modunu durdurur
+	 */
+	async stopSelection() {
+		if (!this.isSelecting) {
+			return false;
+		}
+
+		return new Promise((resolve, reject) => {
+			try {
+				const success = nativeBinding.stopWindowSelection();
+				
+				// Timer'ı durdur
+				if (this.selectionTimer) {
+					clearInterval(this.selectionTimer);
+					this.selectionTimer = null;
+				}
+
+				this.isSelecting = false;
+				this.lastStatus = null;
+
+				this.emit("selectionStopped");
+				resolve(success);
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+
+	/**
+	 * Selection durumunu kontrol eder ve event yayar
+	 */
+	checkSelectionStatus() {
+		if (!this.isSelecting) return;
+
+		try {
+			const status = nativeBinding.getWindowSelectionStatus();
+			
+			// Seçim tamamlandı mı kontrol et
+			if (status.hasSelectedWindow && !this.selectedWindow) {
+				const windowInfo = nativeBinding.getSelectedWindowInfo();
+				if (windowInfo) {
+					this.selectedWindow = windowInfo;
+					this.isSelecting = false;
+					
+					// Timer'ı durdur
+					if (this.selectionTimer) {
+						clearInterval(this.selectionTimer);
+						this.selectionTimer = null;
+					}
+
+					this.emit("windowSelected", windowInfo);
+					return;
+				}
+			}
+
+			// Mevcut pencere değişti mi kontrol et
+			if (this.lastStatus) {
+				const lastWindow = this.lastStatus.currentWindow;
+				const currentWindow = status.currentWindow;
+				
+				if (!lastWindow && currentWindow) {
+					// Yeni pencere üstüne gelindi
+					this.emit("windowEntered", currentWindow);
+				} else if (lastWindow && !currentWindow) {
+					// Pencere üstünden ayrıldı
+					this.emit("windowLeft", lastWindow);
+				} else if (lastWindow && currentWindow && 
+						  (lastWindow.id !== currentWindow.id || 
+						   lastWindow.title !== currentWindow.title || 
+						   lastWindow.appName !== currentWindow.appName)) {
+					// Farklı bir pencereye geçildi
+					this.emit("windowLeft", lastWindow);
+					this.emit("windowEntered", currentWindow);
+				}
+			} else if (!this.lastStatus && status.currentWindow) {
+				// İlk pencere detection
+				this.emit("windowEntered", status.currentWindow);
+			}
+
+			this.lastStatus = status;
+		} catch (error) {
+			this.emit("error", error);
+		}
+	}
+
+	/**
+	 * Seçilen pencere bilgisini döndürür
+	 */
+	getSelectedWindow() {
+		return this.selectedWindow;
+	}
+
+	/**
+	 * Seçim durumunu döndürür
+	 */
+	getStatus() {
+		try {
+			const nativeStatus = nativeBinding.getWindowSelectionStatus();
+			return {
+				isSelecting: this.isSelecting && nativeStatus.isSelecting,
+				hasSelectedWindow: !!this.selectedWindow,
+				selectedWindow: this.selectedWindow,
+				nativeStatus: nativeStatus
+			};
+		} catch (error) {
+			return {
+				isSelecting: this.isSelecting,
+				hasSelectedWindow: !!this.selectedWindow,
+				selectedWindow: this.selectedWindow,
+				error: error.message
+			};
+		}
+	}
+
+	/**
+	 * Promise tabanlı pencere seçimi
+	 * Kullanıcı bir pencere seçene kadar bekler
+	 */
+	async selectWindow() {
+		if (this.isSelecting) {
+			throw new Error("Selection already in progress");
+		}
+
+		return new Promise(async (resolve, reject) => {
+			try {
+				// Event listener'ları ayarla
+				const onWindowSelected = (windowInfo) => {
+					this.removeAllListeners("windowSelected");
+					this.removeAllListeners("error");
+					resolve(windowInfo);
+				};
+
+				const onError = (error) => {
+					this.removeAllListeners("windowSelected");
+					this.removeAllListeners("error");
+					reject(error);
+				};
+
+				this.once("windowSelected", onWindowSelected);
+				this.once("error", onError);
+
+				// Seçimi başlat
+				await this.startSelection();
+
+			} catch (error) {
+				this.removeAllListeners("windowSelected");
+				this.removeAllListeners("error");
+				reject(error);
+			}
+		});
+	}
+
+	/**
+	 * 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
+	 */
+	async cleanup() {
+		if (this.isSelecting) {
+			await this.stopSelection();
+		}
+
+		// Timer'ı temizle
+		if (this.selectionTimer) {
+			clearInterval(this.selectionTimer);
+			this.selectionTimer = null;
+		}
+
+		// Event listener'ları temizle
+		this.removeAllListeners();
+
+		// State'i sıfırla
+		this.selectedWindow = null;
+		this.lastStatus = null;
+		this.isSelecting = false;
+	}
+
+	/**
+	 * macOS'ta pencere seçim izinlerini kontrol eder
+	 */
+	async checkPermissions() {
+		try {
+			// Mevcut MacRecorder'dan permission check'i kullan
+			const MacRecorder = require("./index.js");
+			const recorder = new MacRecorder();
+			return await recorder.checkPermissions();
+		} catch (error) {
+			return {
+				screenRecording: false,
+				accessibility: false,
+				error: error.message
+			};
+		}
+	}
+}
+
+module.exports = WindowSelector;

package/working-example.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+const WindowSelector = require('./window-selector');
+
+async function workingExample() {
+    console.log('🎯 Window Selector - Working Example');
+    console.log('====================================\n');
+
+    const selector = new WindowSelector();
+
+    try {
+        console.log('Starting window selection...');
+        console.log('Move cursor over different windows to see detection');
+        console.log('The system will detect which window is under cursor');
+        console.log('Press Ctrl+C to stop\n');
+
+        let currentWindow = null;
+
+        selector.on('windowEntered', (window) => {
+            currentWindow = window;
+            console.log(`\n🏠 ENTERED WINDOW:`);
+            console.log(`   App: ${window.appName}`);
+            console.log(`   Title: "${window.title}"`);
+            console.log(`   Position: (${window.x}, ${window.y})`);
+            console.log(`   Size: ${window.width} x ${window.height}`);
+            console.log(`   💡 This window is now highlighted (overlay may not be visible due to macOS security)`);
+        });
+
+        selector.on('windowLeft', (window) => {
+            console.log(`\n🚪 LEFT WINDOW: ${window.appName} - "${window.title}"`);
+            currentWindow = null;
+        });
+
+        selector.on('windowSelected', (selectedWindow) => {
+            console.log('\n🎉 WINDOW SELECTED!');
+            console.log('==================');
+            console.log(`App: ${selectedWindow.appName}`);
+            console.log(`Title: "${selectedWindow.title}"`);
+            console.log(`Position: (${selectedWindow.x}, ${selectedWindow.y})`);
+            console.log(`Size: ${selectedWindow.width} x ${selectedWindow.height}`);
+            console.log(`Screen: ${selectedWindow.screenId}`);
+            process.exit(0);
+        });
+
+        // Manual selection trigger
+        let readline = require('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        console.log('💡 Pro tip: Press ENTER to select the current window under cursor');
+        rl.on('line', () => {
+            if (currentWindow) {
+                console.log('\n✅ Manually selecting current window...');
+                selector.emit('windowSelected', currentWindow);
+            } else {
+                console.log('\n⚠️  No window under cursor. Move cursor over a window first.');
+            }
+        });
+
+        await selector.startSelection();
+
+        // Status monitoring
+        let statusCount = 0;
+        const statusInterval = setInterval(() => {
+            const status = selector.getStatus();
+            statusCount++;
+            
+            if (statusCount % 20 === 0) { // Every 10 seconds
+                console.log(`\n📊 Status (${statusCount/2}s): Windows detected: ${status.nativeStatus?.windowCount || 0}`);
+                if (status.nativeStatus?.currentWindow) {
+                    console.log(`   Current: ${status.nativeStatus.currentWindow.appName}`);
+                }
+            }
+        }, 500);
+
+        process.on('SIGINT', async () => {
+            clearInterval(statusInterval);
+            rl.close();
+            console.log('\n🛑 Stopping window selector...');
+            await selector.cleanup();
+            console.log('✅ Cleanup completed');
+            process.exit(0);
+        });
+
+    } catch (error) {
+        console.error('\n❌ Error:', error.message);
+        console.error(error.stack);
+        process.exit(1);
+    }
+}
+
+workingExample();