node-mac-recorder 2.4.8 → 2.4.9

package/.claude/settings.local.json

@@ -25,7 +25,8 @@
       "Bash(git checkout:*)",
       "Bash(ELECTRON_VERSION=25.0.0 node -e \"\nconsole.log(''ELECTRON_VERSION env:'', process.env.ELECTRON_VERSION);\nconsole.log(''getenv result would be:'', process.env.ELECTRON_VERSION || ''null'');\n\")",
       "Bash(ELECTRON_VERSION=25.0.0 node test-env-detection.js)",
-      "Bash(ELECTRON_VERSION=25.0.0 node test-native-call.js)"
+      "Bash(ELECTRON_VERSION=25.0.0 node test-native-call.js)",
+      "Bash(chmod:*)"
     ],
     "deny": []
   }

package/electron-window-selector.js

@@ -0,0 +1,671 @@
+const { EventEmitter } = require("events");
+const path = require("path");
+
+// Native modülü yükle
+let nativeBinding;
+try {
+    if (process.platform === "darwin" && process.arch === "arm64") {
+        nativeBinding = require("./prebuilds/darwin-arm64/node.napi.node");
+    } else {
+        nativeBinding = require("./build/Release/mac_recorder.node");
+    }
+} catch (error) {
+    try {
+        nativeBinding = require("./build/Release/mac_recorder.node");
+    } catch (_) {
+        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 ElectronWindowSelector extends EventEmitter {
+    constructor() {
+        super();
+        this.isSelecting = false;
+        this.isScreenSelecting = false;
+        this.selectedWindow = null;
+        this.selectedScreen = null;
+        this.selectionTimer = null;
+        this.lastStatus = null;
+        
+        // Electron detection
+        this.isElectron = !!(process.versions && process.versions.electron) || 
+                         !!(process.env.ELECTRON_VERSION) ||
+                         !!(process.env.ELECTRON_RUN_AS_NODE);
+        
+        console.log(`🔍 ElectronWindowSelector: ${this.isElectron ? 'Electron' : 'Node.js'} environment detected`);
+    }
+
+    /**
+     * Pencere seçim modunu başlatır - Electron'da overlay ile
+     * @returns {Promise<Object>} Seçilen pencere bilgisi
+     */
+    async selectWindow() {
+        if (this.isSelecting) {
+            throw new Error("Window selection is already in progress");
+        }
+
+        return new Promise((resolve, reject) => {
+            try {
+                // Event listener'ları ayarla
+                const onWindowSelected = (windowInfo) => {
+                    this.removeAllListeners("windowSelected");
+                    this.removeAllListeners("error");
+                    this.removeAllListeners("selectionCancelled");
+                    resolve(windowInfo);
+                };
+
+                const onError = (error) => {
+                    this.removeAllListeners("windowSelected");
+                    this.removeAllListeners("error");
+                    this.removeAllListeners("selectionCancelled");
+                    reject(error);
+                };
+
+                const onCancelled = () => {
+                    this.removeAllListeners("windowSelected");
+                    this.removeAllListeners("error");
+                    this.removeAllListeners("selectionCancelled");
+                    reject(new Error("Window selection was cancelled"));
+                };
+
+                this.once("windowSelected", onWindowSelected);
+                this.once("error", onError);
+                this.once("selectionCancelled", onCancelled);
+
+                // Native window selection başlat (overlay ile)
+                this.startWindowSelectionWithOverlay();
+
+            } catch (error) {
+                this.removeAllListeners("windowSelected");
+                this.removeAllListeners("error");
+                this.removeAllListeners("selectionCancelled");
+                reject(error);
+            }
+        });
+    }
+
+    /**
+     * Ekran seçim modunu başlatır - Electron'da overlay ile
+     * @returns {Promise<Object>} Seçilen ekran bilgisi
+     */
+    async selectScreen() {
+        if (this.isScreenSelecting) {
+            throw new Error("Screen selection is already in progress");
+        }
+
+        return new Promise((resolve, reject) => {
+            try {
+                // Event listener'ları ayarla
+                const onScreenSelected = (screenInfo) => {
+                    this.removeAllListeners("screenSelected");
+                    this.removeAllListeners("error");
+                    this.removeAllListeners("selectionCancelled");
+                    resolve(screenInfo);
+                };
+
+                const onError = (error) => {
+                    this.removeAllListeners("screenSelected");
+                    this.removeAllListeners("error");
+                    this.removeAllListeners("selectionCancelled");
+                    reject(error);
+                };
+
+                const onCancelled = () => {
+                    this.removeAllListeners("screenSelected");
+                    this.removeAllListeners("error");
+                    this.removeAllListeners("selectionCancelled");
+                    reject(new Error("Screen selection was cancelled"));
+                };
+
+                this.once("screenSelected", onScreenSelected);
+                this.once("error", onError);
+                this.once("selectionCancelled", onCancelled);
+
+                // Native screen selection başlat (overlay ile)
+                this.startScreenSelectionWithOverlay();
+
+            } catch (error) {
+                this.removeAllListeners("screenSelected");
+                this.removeAllListeners("error");
+                this.removeAllListeners("selectionCancelled");
+                reject(error);
+            }
+        });
+    }
+
+    /**
+     * Native window selection'ı overlay ile başlatır
+     */
+    async startWindowSelectionWithOverlay() {
+        try {
+            // Native binding'den window selection başlat
+            const success = await this.callNativeWindowSelection();
+            
+            if (success) {
+                this.isSelecting = true;
+                this.selectedWindow = null;
+
+                // Polling timer başlat (overlay update'leri için)
+                this.selectionTimer = setInterval(() => {
+                    this.checkWindowSelectionStatus();
+                }, 50); // 20 FPS
+
+                this.emit("selectionStarted");
+                console.log("✅ Window selection overlay started");
+            } else {
+                throw new Error("Failed to start window selection overlay");
+            }
+        } catch (error) {
+            console.error("❌ Window selection failed:", error.message);
+            this.emit("error", error);
+        }
+    }
+
+    /**
+     * Native screen selection'ı overlay ile başlatır
+     */
+    async startScreenSelectionWithOverlay() {
+        try {
+            // Native binding'den screen selection başlat
+            const success = await this.callNativeScreenSelection();
+            
+            if (success) {
+                this.isScreenSelecting = true;
+                this.selectedScreen = null;
+
+                // Polling timer başlat (overlay update'leri için)
+                this.selectionTimer = setInterval(() => {
+                    this.checkScreenSelectionStatus();
+                }, 50); // 20 FPS
+
+                this.emit("screenSelectionStarted");
+                console.log("✅ Screen selection overlay started");
+            } else {
+                throw new Error("Failed to start screen selection overlay");
+            }
+        } catch (error) {
+            console.error("❌ Screen selection failed:", error.message);
+            this.emit("error", error);
+        }
+    }
+
+    /**
+     * Native window selection API'yi çağırır - Electron-compatible
+     */
+    async callNativeWindowSelection() {
+        try {
+            // Electron'da bile overlay'lerin çalışması için environment variable'ı geçici olarak kaldır
+            const originalElectronVersion = process.env.ELECTRON_VERSION;
+            const originalElectronRunAs = process.env.ELECTRON_RUN_AS_NODE;
+            
+            // Geçici olarak Electron environment variable'larını kaldır
+            delete process.env.ELECTRON_VERSION;
+            delete process.env.ELECTRON_RUN_AS_NODE;
+            
+            try {
+                // Native function çağır
+                const result = nativeBinding.startWindowSelection();
+                return result;
+            } finally {
+                // Environment variable'ları geri yükle
+                if (originalElectronVersion) {
+                    process.env.ELECTRON_VERSION = originalElectronVersion;
+                }
+                if (originalElectronRunAs) {
+                    process.env.ELECTRON_RUN_AS_NODE = originalElectronRunAs;
+                }
+            }
+        } catch (error) {
+            console.error("Native window selection failed:", error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Native screen selection API'yi çağırır - Electron-compatible
+     */
+    async callNativeScreenSelection() {
+        try {
+            // Electron'da bile overlay'lerin çalışması için environment variable'ı geçici olarak kaldır
+            const originalElectronVersion = process.env.ELECTRON_VERSION;
+            const originalElectronRunAs = process.env.ELECTRON_RUN_AS_NODE;
+            
+            // Geçici olarak Electron environment variable'larını kaldır
+            delete process.env.ELECTRON_VERSION;
+            delete process.env.ELECTRON_RUN_AS_NODE;
+            
+            try {
+                // Native function çağır
+                const result = nativeBinding.startScreenSelection();
+                return result;
+            } finally {
+                // Environment variable'ları geri yükle
+                if (originalElectronVersion) {
+                    process.env.ELECTRON_VERSION = originalElectronVersion;
+                }
+                if (originalElectronRunAs) {
+                    process.env.ELECTRON_RUN_AS_NODE = originalElectronRunAs;
+                }
+            }
+        } catch (error) {
+            console.error("Native screen selection failed:", error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Window selection durumunu kontrol eder
+     */
+    checkWindowSelectionStatus() {
+        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;
+                    }
+
+                    console.log("🎯 Window selected:", windowInfo.title || windowInfo.appName);
+                    this.emit("windowSelected", windowInfo);
+                    return;
+                }
+            }
+
+            // Mouse movement events için mevcut pencere değişikliklerini 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) {
+            console.error("Window selection status check error:", error.message);
+            this.emit("error", error);
+        }
+    }
+
+    /**
+     * Screen selection durumunu kontrol eder
+     */
+    checkScreenSelectionStatus() {
+        if (!this.isScreenSelecting) return;
+
+        try {
+            const selectedScreen = nativeBinding.getSelectedScreenInfo();
+            
+            if (selectedScreen && !this.selectedScreen) {
+                this.selectedScreen = selectedScreen;
+                this.isScreenSelecting = false;
+
+                // Timer'ı durdur
+                if (this.selectionTimer) {
+                    clearInterval(this.selectionTimer);
+                    this.selectionTimer = null;
+                }
+
+                console.log("🖥️ Screen selected:", selectedScreen);
+                this.emit("screenSelected", selectedScreen);
+            }
+        } catch (error) {
+            console.error("Screen selection status check error:", error.message);
+            this.emit("error", error);
+        }
+    }
+
+    /**
+     * Window selection'ı durdurur
+     */
+    async stopWindowSelection() {
+        if (!this.isSelecting) {
+            return false;
+        }
+
+        try {
+            // Environment variable'ları geçici kaldır
+            const originalElectronVersion = process.env.ELECTRON_VERSION;
+            const originalElectronRunAs = process.env.ELECTRON_RUN_AS_NODE;
+            
+            delete process.env.ELECTRON_VERSION;
+            delete process.env.ELECTRON_RUN_AS_NODE;
+            
+            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");
+                console.log("🛑 Window selection stopped");
+                return success;
+            } finally {
+                // Environment variable'ları geri yükle
+                if (originalElectronVersion) {
+                    process.env.ELECTRON_VERSION = originalElectronVersion;
+                }
+                if (originalElectronRunAs) {
+                    process.env.ELECTRON_RUN_AS_NODE = originalElectronRunAs;
+                }
+            }
+        } catch (error) {
+            console.error("Stop window selection error:", error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Screen selection'ı durdurur
+     */
+    async stopScreenSelection() {
+        if (!this.isScreenSelecting) {
+            return false;
+        }
+
+        try {
+            // Environment variable'ları geçici kaldır
+            const originalElectronVersion = process.env.ELECTRON_VERSION;
+            const originalElectronRunAs = process.env.ELECTRON_RUN_AS_NODE;
+            
+            delete process.env.ELECTRON_VERSION;
+            delete process.env.ELECTRON_RUN_AS_NODE;
+            
+            try {
+                const success = nativeBinding.stopScreenSelection();
+
+                // Timer'ı durdur
+                if (this.selectionTimer) {
+                    clearInterval(this.selectionTimer);
+                    this.selectionTimer = null;
+                }
+
+                this.isScreenSelecting = false;
+
+                this.emit("screenSelectionStopped");
+                console.log("🛑 Screen selection stopped");
+                return success;
+            } finally {
+                // Environment variable'ları geri yükle
+                if (originalElectronVersion) {
+                    process.env.ELECTRON_VERSION = originalElectronVersion;
+                }
+                if (originalElectronRunAs) {
+                    process.env.ELECTRON_RUN_AS_NODE = originalElectronRunAs;
+                }
+            }
+        } catch (error) {
+            console.error("Stop screen selection error:", error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Recording preview gösterir
+     * @param {Object} windowInfo - Pencere bilgisi
+     */
+    async showRecordingPreview(windowInfo) {
+        if (!windowInfo) {
+            throw new Error("Window info is required");
+        }
+
+        try {
+            // Environment variable'ları geçici kaldır
+            const originalElectronVersion = process.env.ELECTRON_VERSION;
+            const originalElectronRunAs = process.env.ELECTRON_RUN_AS_NODE;
+            
+            delete process.env.ELECTRON_VERSION;
+            delete process.env.ELECTRON_RUN_AS_NODE;
+            
+            try {
+                const success = nativeBinding.showRecordingPreview(windowInfo);
+                console.log("🎬 Recording preview shown");
+                return success;
+            } finally {
+                // Environment variable'ları geri yükle
+                if (originalElectronVersion) {
+                    process.env.ELECTRON_VERSION = originalElectronVersion;
+                }
+                if (originalElectronRunAs) {
+                    process.env.ELECTRON_RUN_AS_NODE = originalElectronRunAs;
+                }
+            }
+        } catch (error) {
+            console.error("Show recording preview error:", error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Recording preview'ı gizler
+     */
+    async hideRecordingPreview() {
+        try {
+            // Environment variable'ları geçici kaldır
+            const originalElectronVersion = process.env.ELECTRON_VERSION;
+            const originalElectronRunAs = process.env.ELECTRON_RUN_AS_NODE;
+            
+            delete process.env.ELECTRON_VERSION;
+            delete process.env.ELECTRON_RUN_AS_NODE;
+            
+            try {
+                const success = nativeBinding.hideRecordingPreview();
+                console.log("🎬 Recording preview hidden");
+                return success;
+            } finally {
+                // Environment variable'ları geri yükle
+                if (originalElectronVersion) {
+                    process.env.ELECTRON_VERSION = originalElectronVersion;
+                }
+                if (originalElectronRunAs) {
+                    process.env.ELECTRON_RUN_AS_NODE = originalElectronRunAs;
+                }
+            }
+        } catch (error) {
+            console.error("Hide recording preview error:", error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Screen recording preview gösterir
+     * @param {Object} screenInfo - Ekran bilgisi
+     */
+    async showScreenRecordingPreview(screenInfo) {
+        if (!screenInfo) {
+            throw new Error("Screen info is required");
+        }
+
+        try {
+            // Environment variable'ları geçici kaldır
+            const originalElectronVersion = process.env.ELECTRON_VERSION;
+            const originalElectronRunAs = process.env.ELECTRON_RUN_AS_NODE;
+            
+            delete process.env.ELECTRON_VERSION;
+            delete process.env.ELECTRON_RUN_AS_NODE;
+            
+            try {
+                const success = nativeBinding.showScreenRecordingPreview(screenInfo);
+                console.log("🖥️ Screen recording preview shown");
+                return success;
+            } finally {
+                // Environment variable'ları geri yükle
+                if (originalElectronVersion) {
+                    process.env.ELECTRON_VERSION = originalElectronVersion;
+                }
+                if (originalElectronRunAs) {
+                    process.env.ELECTRON_RUN_AS_NODE = originalElectronRunAs;
+                }
+            }
+        } catch (error) {
+            console.error("Show screen recording preview error:", error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Screen recording preview'ı gizler
+     */
+    async hideScreenRecordingPreview() {
+        try {
+            // Environment variable'ları geçici kaldır
+            const originalElectronVersion = process.env.ELECTRON_VERSION;
+            const originalElectronRunAs = process.env.ELECTRON_RUN_AS_NODE;
+            
+            delete process.env.ELECTRON_VERSION;
+            delete process.env.ELECTRON_RUN_AS_NODE;
+            
+            try {
+                const success = nativeBinding.hideScreenRecordingPreview();
+                console.log("🖥️ Screen recording preview hidden");
+                return success;
+            } finally {
+                // Environment variable'ları geri yükle
+                if (originalElectronVersion) {
+                    process.env.ELECTRON_VERSION = originalElectronVersion;
+                }
+                if (originalElectronRunAs) {
+                    process.env.ELECTRON_RUN_AS_NODE = originalElectronRunAs;
+                }
+            }
+        } catch (error) {
+            console.error("Hide screen recording preview error:", error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Mevcut durumu döndürür
+     */
+    getStatus() {
+        return {
+            isSelecting: this.isSelecting,
+            isScreenSelecting: this.isScreenSelecting,
+            hasSelectedWindow: !!this.selectedWindow,
+            hasSelectedScreen: !!this.selectedScreen,
+            selectedWindow: this.selectedWindow,
+            selectedScreen: this.selectedScreen,
+            isElectron: this.isElectron
+        };
+    }
+
+    /**
+     * Seçilen pencere bilgisini döndürür
+     */
+    getSelectedWindow() {
+        return this.selectedWindow;
+    }
+
+    /**
+     * Seçilen ekran bilgisini döndürür
+     */
+    getSelectedScreen() {
+        return this.selectedScreen;
+    }
+
+    /**
+     * Tüm kaynakları temizler
+     */
+    async cleanup() {
+        try {
+            // Selection'ları durdur
+            if (this.isSelecting) {
+                await this.stopWindowSelection();
+            }
+            
+            if (this.isScreenSelecting) {
+                await this.stopScreenSelection();
+            }
+
+            // Timer'ları temizle
+            if (this.selectionTimer) {
+                clearInterval(this.selectionTimer);
+                this.selectionTimer = null;
+            }
+
+            // Preview'ları gizle
+            try {
+                await this.hideRecordingPreview();
+                await this.hideScreenRecordingPreview();
+            } catch (error) {
+                // Preview errors are not critical
+                console.warn("Preview cleanup warning:", error.message);
+            }
+
+            // Event listener'ları temizle
+            this.removeAllListeners();
+
+            // State'i sıfırla
+            this.selectedWindow = null;
+            this.selectedScreen = null;
+            this.lastStatus = null;
+            this.isSelecting = false;
+            this.isScreenSelecting = false;
+
+            console.log("🧹 ElectronWindowSelector cleaned up");
+        } catch (error) {
+            console.error("Cleanup error:", error.message);
+        }
+    }
+
+    /**
+     * İzinleri kontrol eder
+     */
+    async checkPermissions() {
+        try {
+            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 = ElectronWindowSelector;

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.4.8",
+	"version": "2.4.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;
         
@@ -996,7 +1073,7 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
             }
             
             // Store windows for later retrieval via getWindowSelectionStatus
-            g_allWindows = [windows mutableCopy];
+            g_allWindows = [getAllSelectableWindows() mutableCopy];
             g_isWindowSelecting = true;
             
             // Return true to indicate windows are available
@@ -1017,7 +1094,7 @@ Napi::Value StartWindowSelection(const Napi::CallbackInfo& info) {
     
     @try {
         // Get all windows
-        g_allWindows = getAllSelectableWindows();
+        g_allWindows = [getAllSelectableWindows() mutableCopy];
         
         if (!g_allWindows || [g_allWindows count] == 0) {
             Napi::Error::New(env, "No selectable windows found").ThrowAsJavaScriptException();

package/test-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();