node-mac-recorder 2.22.24 → 2.22.32

package/index.js

@@ -1,7 +1,6 @@
 const { EventEmitter } = require("events");
 const path = require("path");
 const fs = require("fs");
-const cursorCapturePolling = require("./lib/cursorCapture/polling");
 
 // Auto-switch to Electron-safe implementation when running under Electron and binary exists
 let USE_ELECTRON_SAFE = false;
@@ -1341,17 +1340,365 @@ class MacRecorder extends EventEmitter {
 		});
 	}
 
+	/**
+	 * Event'in kaydedilip kaydedilmeyeceğini belirler
+	 */
+	shouldCaptureEvent(currentData) {
+		if (!this.lastCapturedData) {
+			return true; // İlk event
+		}
+
+		const last = this.lastCapturedData;
+
+		// Event type değişmişse
+		if (currentData.type !== last.type) {
+			return true;
+		}
+
+		// Pozisyon değişmişse (minimum 2 pixel tolerans)
+		if (
+			Math.abs(currentData.x - last.x) >= 2 ||
+			Math.abs(currentData.y - last.y) >= 2
+		) {
+			return true;
+		}
+
+		// Cursor type değişmişse
+		if (currentData.cursorType !== last.cursorType) {
+			return true;
+		}
+
+		// Hiçbir değişiklik yoksa kaydetme
+		return false;
+	}
+
+	/**
+	 * Unified cursor capture for all recording types - uses video-relative coordinates
+	 * @param {string|number} intervalOrFilepath - Cursor data JSON dosya yolu veya interval
+	 * @param {Object} options - Cursor capture seçenekleri
+	 * @param {boolean} options.videoRelative - Use video-relative coordinates (recommended)
+	 * @param {Object} options.displayInfo - Display information for coordinate transformation
+	 * @param {string} options.recordingType - Type of recording: 'display', 'window', 'area'
+	 * @param {Object} options.captureArea - Capture area for area recording coordinate transformation
+	 * @param {number} options.windowId - Window ID for window recording coordinate transformation
+	 * @param {number} options.startTimestamp - Pre-defined start timestamp for synchronization (optional)
+	 */
 	async startCursorCapture(intervalOrFilepath = 100, options = {}) {
-		return cursorCapturePolling.startCursorCapture(
-			this,
-			nativeBinding,
-			intervalOrFilepath,
-			options,
-		);
+		let filepath;
+		let interval = 20; // Default 50 FPS
+
+		// Parameter parsing: number = interval, string = filepath
+		if (typeof intervalOrFilepath === "number") {
+			interval = Math.max(10, intervalOrFilepath); // Min 10ms
+			filepath = `cursor-data-${Date.now()}.json`;
+		} else if (typeof intervalOrFilepath === "string") {
+			filepath = intervalOrFilepath;
+		} else {
+			throw new Error(
+				"Parameter must be interval (number) or filepath (string)"
+			);
+		}
+
+		if (this.cursorCaptureInterval) {
+			throw new Error("Cursor capture is already running");
+		}
+
+		// SYNC FIX: Use pre-defined timestamp if provided for synchronization
+		const syncStartTime = options.startTimestamp || Date.now();
+
+		// Fetch window bounds for multi-window recording
+		if (options.multiWindowBounds && options.multiWindowBounds.length > 0) {
+			try {
+				const allWindows = await this.getWindows();
+				// Match window IDs and populate bounds
+				for (const windowInfo of options.multiWindowBounds) {
+					const windowData = allWindows.find(w => w.id === windowInfo.windowId);
+					if (windowData) {
+						windowInfo.bounds = {
+							x: windowData.x || 0,
+							y: windowData.y || 0,
+							width: windowData.width || 0,
+							height: windowData.height || 0
+						};
+					}
+				}
+			} catch (error) {
+				console.warn('Failed to fetch window bounds for multi-window cursor tracking:', error.message);
+			}
+		}
+
+		// Use video-relative coordinate system for all recording types
+		if (options.videoRelative && options.displayInfo) {
+			// Calculate video offset based on recording type
+			let videoOffsetX = 0;
+			let videoOffsetY = 0;
+			let videoWidth = options.displayInfo.width || options.displayInfo.logicalWidth;
+			let videoHeight = options.displayInfo.height || options.displayInfo.logicalHeight;
+
+			if (options.recordingType === 'window' && options.windowId) {
+				// For window recording: offset = window position in display
+				if (options.captureArea) {
+					videoOffsetX = options.captureArea.x;
+					videoOffsetY = options.captureArea.y;
+					videoWidth = options.captureArea.width;
+					videoHeight = options.captureArea.height;
+				}
+			} else if (options.recordingType === 'area' && options.captureArea) {
+				// For area recording: offset = area position in display
+				videoOffsetX = options.captureArea.x;
+				videoOffsetY = options.captureArea.y;
+				videoWidth = options.captureArea.width;
+				videoHeight = options.captureArea.height;
+			}
+			// For display recording: offset remains 0,0
+
+			this.cursorDisplayInfo = {
+				displayId: options.displayInfo.displayId || options.displayInfo.id,
+				displayX: options.displayInfo.x || 0,
+				displayY: options.displayInfo.y || 0,
+				displayWidth: options.displayInfo.width || options.displayInfo.logicalWidth,
+				displayHeight: options.displayInfo.height || options.displayInfo.logicalHeight,
+				videoOffsetX: videoOffsetX,
+				videoOffsetY: videoOffsetY,
+				videoWidth: videoWidth,
+				videoHeight: videoHeight,
+				videoRelative: true,
+				recordingType: options.recordingType || 'display',
+				// Store additional context for debugging
+				captureArea: options.captureArea,
+				windowId: options.windowId,
+				// Multi-window bounds for location detection
+				multiWindowBounds: options.multiWindowBounds || null
+			};
+		} else if (this.recordingDisplayInfo) {
+			// Fallback: Use recording display info if available
+			this.cursorDisplayInfo = {
+				...this.recordingDisplayInfo,
+				displayX: this.recordingDisplayInfo.x || 0,
+				displayY: this.recordingDisplayInfo.y || 0,
+				displayWidth: this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
+				displayHeight: this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
+				videoOffsetX: 0,
+				videoOffsetY: 0,
+				videoWidth: this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
+				videoHeight: this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
+				videoRelative: true,
+				recordingType: options.recordingType || 'display',
+				multiWindowBounds: options.multiWindowBounds || null
+			};
+		} else {
+			// Final fallback: Main display global coordinates
+			try {
+				const displays = await this.getDisplays();
+				const mainDisplay = displays.find((d) => d.isPrimary) || displays[0];
+				if (mainDisplay) {
+					this.cursorDisplayInfo = {
+						displayId: mainDisplay.id,
+						x: mainDisplay.x,
+						y: mainDisplay.y,
+						width: parseInt(mainDisplay.resolution.split("x")[0]),
+						height: parseInt(mainDisplay.resolution.split("x")[1]),
+						multiWindowBounds: options.multiWindowBounds || null
+					};
+				}
+			} catch (error) {
+				console.warn("Main display bilgisi alınamadı:", error.message);
+				this.cursorDisplayInfo = null; // Fallback: global koordinatlar
+			}
+		}
+
+		return new Promise((resolve, reject) => {
+			try {
+				// Dosyayı oluştur ve temizle
+				const fs = require("fs");
+				fs.writeFileSync(filepath, "[");
+
+				this.cursorCaptureFile = filepath;
+				// SYNC FIX: Use synchronized start time for accurate timestamp calculation
+				this.cursorCaptureStartTime = syncStartTime;
+				this.cursorCaptureFirstWrite = true;
+				this.lastCapturedData = null;
+				// Store session timestamp for sync metadata
+				this.cursorCaptureSessionTimestamp = this.sessionTimestamp;
+
+				// JavaScript interval ile polling yap (daha sık - mouse event'leri yakalamak için)
+				this.cursorCaptureInterval = setInterval(() => {
+					try {
+						const position = nativeBinding.getCursorPosition();
+						const timestamp = Date.now() - this.cursorCaptureStartTime;
+
+						// Video-relative coordinate transformation for all recording types
+						let x = position.x;
+						let y = position.y;
+						let coordinateSystem = "global";
+
+						// Apply video-relative transformation for all recording types
+						if (this.cursorDisplayInfo && this.cursorDisplayInfo.videoRelative) {
+							// Step 1: Transform global → display-relative coordinates
+							const displayRelativeX = position.x - this.cursorDisplayInfo.displayX;
+							const displayRelativeY = position.y - this.cursorDisplayInfo.displayY;
+
+							// Step 2: Transform display-relative → video-relative coordinates
+							x = displayRelativeX - this.cursorDisplayInfo.videoOffsetX;
+							y = displayRelativeY - this.cursorDisplayInfo.videoOffsetY;
+							coordinateSystem = "video-relative";
+
+							// Bounds check for video area (don't skip, just note if outside)
+							const outsideVideo = x < 0 || y < 0 ||
+								x >= this.cursorDisplayInfo.videoWidth ||
+								y >= this.cursorDisplayInfo.videoHeight;
+
+							// For debugging - add metadata if cursor is outside video area
+							if (outsideVideo) {
+								coordinateSystem = "video-relative-outside";
+							}
+						}
+
+						const cursorData = {
+							x: x,
+							y: y,
+							timestamp: timestamp,
+							unixTimeMs: Date.now(),
+							cursorType: position.cursorType,
+							type: position.eventType || "move",
+							coordinateSystem: coordinateSystem,
+							// Video-relative metadata for all recording types
+							recordingType: this.cursorDisplayInfo?.recordingType || "display",
+							videoInfo: this.cursorDisplayInfo ? {
+								width: this.cursorDisplayInfo.videoWidth,
+								height: this.cursorDisplayInfo.videoHeight,
+								offsetX: this.cursorDisplayInfo.videoOffsetX,
+								offsetY: this.cursorDisplayInfo.videoOffsetY
+							} : {},
+							displayInfo: this.cursorDisplayInfo ? {
+								displayId: this.cursorDisplayInfo.displayId,
+								width: this.cursorDisplayInfo.displayWidth,
+								height: this.cursorDisplayInfo.displayHeight
+							} : {}
+						};
+
+						// Multi-window location detection with window-relative coordinates
+						if (this.cursorDisplayInfo?.multiWindowBounds && this.cursorDisplayInfo.multiWindowBounds.length > 0) {
+							const location = { hover: null, click: null };
+							let windowRelativeCoords = null;
+
+							// Detect which window the cursor is over
+							for (const windowInfo of this.cursorDisplayInfo.multiWindowBounds) {
+								if (windowInfo.bounds) {
+									const { x: wx, y: wy, width: ww, height: wh } = windowInfo.bounds;
+									// Check if cursor is inside window bounds (using global coordinates)
+									if (position.x >= wx && position.x <= wx + ww &&
+										position.y >= wy && position.y <= wy + wh) {
+										location.hover = windowInfo.windowId;
+
+										// Calculate window-relative coordinates
+										// These coords are relative to the window's top-left corner (0,0)
+										// This allows the desktop app to position cursor correctly
+										// regardless of where the window is placed on canvas
+										windowRelativeCoords = {
+											windowId: windowInfo.windowId,
+											x: position.x - wx,
+											y: position.y - wy,
+											// Also include window dimensions for reference
+											windowWidth: ww,
+											windowHeight: wh
+										};
+
+										// If this is a click/drag event, mark click location
+										// Native eventType values: 'mousedown', 'mouseup', 'drag', 'rightmousedown', 'rightmouseup', 'rightdrag'
+										const eventType = position.eventType || '';
+										if (eventType === 'mousedown' ||
+											eventType === 'mouseup' ||
+											eventType === 'drag' ||
+											eventType === 'rightmousedown' ||
+											eventType === 'rightmouseup' ||
+											eventType === 'rightdrag') {
+											location.click = windowInfo.windowId;
+										}
+										break; // Found the window, stop searching
+									}
+								}
+							}
+
+							// Add location info to cursor data
+							cursorData.location = location;
+
+							// Add window-relative coordinates if cursor is over a window
+							if (windowRelativeCoords) {
+								cursorData.windowRelative = windowRelativeCoords;
+							}
+						}
+
+						// Add sync metadata to first event only
+						if (this.cursorCaptureFirstWrite && this.cursorCaptureSessionTimestamp) {
+							cursorData._syncMetadata = {
+								videoStartTime: this.cursorCaptureSessionTimestamp,
+								cursorStartTime: this.cursorCaptureStartTime,
+								offsetMs: this.cursorCaptureStartTime - this.cursorCaptureSessionTimestamp
+							};
+						}
+
+						// Sadece eventType değiştiğinde veya pozisyon değiştiğinde kaydet
+						if (this.shouldCaptureEvent(cursorData)) {
+							// Dosyaya ekle
+							const jsonString = JSON.stringify(cursorData);
+
+							if (this.cursorCaptureFirstWrite) {
+								fs.appendFileSync(filepath, jsonString);
+								this.cursorCaptureFirstWrite = false;
+							} else {
+								fs.appendFileSync(filepath, "," + jsonString);
+							}
+
+							// Son pozisyonu sakla
+							this.lastCapturedData = { ...cursorData };
+						}
+					} catch (error) {
+						console.error("Cursor capture error:", error);
+					}
+				}, interval); // Configurable FPS
+
+				this.emit("cursorCaptureStarted", filepath);
+				resolve(true);
+			} catch (error) {
+				reject(error);
+			}
+		});
 	}
 
+	/**
+	 * Cursor capture durdurur - dosya yazma işlemini sonlandırır
+	 */
 	async stopCursorCapture() {
-		return cursorCapturePolling.stopCursorCapture(this);
+		return new Promise((resolve, reject) => {
+			try {
+				if (!this.cursorCaptureInterval) {
+					return resolve(false);
+				}
+
+				// Interval'ı durdur
+				clearInterval(this.cursorCaptureInterval);
+				this.cursorCaptureInterval = null;
+
+				// Dosyayı kapat
+				if (this.cursorCaptureFile) {
+					const fs = require("fs");
+					fs.appendFileSync(this.cursorCaptureFile, "]");
+					this.cursorCaptureFile = null;
+				}
+
+				// Değişkenleri temizle
+				this.lastCapturedData = null;
+				this.cursorCaptureStartTime = null;
+				this.cursorCaptureFirstWrite = true;
+				this.cursorDisplayInfo = null;
+
+				this.emit("cursorCaptureStopped");
+				resolve(true);
+			} catch (error) {
+				reject(error);
+			}
+		});
 	}
 
 	/**

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -502,8 +502,7 @@ extern "C" bool stopAVFoundationRecording() {
         
         // Finish writing with null checks
         AVAssetWriterInput *writerInput = g_avVideoInput;
-        AVAssetWriter *writerRef = g_avWriter;
-        if (writerInput && writerRef && writerRef.status == AVAssetWriterStatusWriting) {
+        if (writerInput) {
             [writerInput markAsFinished];
         }
         

package/src/cursor_tracker.mm

@@ -7,7 +7,6 @@
 #import <Accessibility/Accessibility.h>
 #import <dispatch/dispatch.h>
 #import "logging.h"
-#import "text_input_ax_snapshot.h"
 #include <vector>
 #include <math.h>
 
@@ -815,10 +814,6 @@ static bool g_leftMouseDown = false;
 static bool g_rightMouseDown = false;
 static NSString *g_lastEventType = @"move";
 
-// Text input (keyboard) tracking state
-static NSTimeInterval g_lastTextInputEmitTime = 0; // Throttle: son textInput event zamanı
-static const NSTimeInterval TEXT_INPUT_THROTTLE_MS = 50; // Min 50ms aralık (20 FPS)
-
 // Accessibility tabanlı cursor tip tespiti
 static NSString* detectCursorTypeUsingAccessibility(CGPoint cursorPos) {
     @autoreleasepool {
@@ -1947,29 +1942,6 @@ void writeToFile(NSDictionary *cursorData) {
     }
 }
 
-// Text input event: Klavye basıldığında focused text field'in caret pozisyonunu yakala
-static void emitTextInputEvent(NSTimeInterval timestamp, NSTimeInterval unixTimeMs, CGPoint mouseLocation) {
-    if (unixTimeMs - g_lastTextInputEmitTime < TEXT_INPUT_THROTTLE_MS) {
-        return;
-    }
-
-    NSDictionary *snap = MRTextInputSnapshotDictionary();
-    if (!snap) {
-        return;
-    }
-
-    NSMutableDictionary *textInputInfo = [NSMutableDictionary dictionaryWithDictionary:snap];
-    textInputInfo[@"x"] = @((int)mouseLocation.x);
-    textInputInfo[@"y"] = @((int)mouseLocation.y);
-    textInputInfo[@"timestamp"] = @(timestamp);
-    textInputInfo[@"unixTimeMs"] = @(unixTimeMs);
-    textInputInfo[@"cursorType"] = @"text";
-    textInputInfo[@"type"] = @"textInput";
-
-    writeToFile(textInputInfo);
-    g_lastTextInputEmitTime = unixTimeMs;
-}
-
 // Event callback for mouse events
 CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon) {
     @autoreleasepool {
@@ -1996,23 +1968,6 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
         // Event tipini belirle
         switch (type) {
             case kCGEventLeftMouseDown:
-                eventType = @"mousedown";
-                // Odak/caret çoğu uygulamada tıklamadan hemen sonra oluşur; kısa gecikmeyle AX caret yaz.
-                // (Sadece tuşta emit edilince ilk tıkta timeline'da textInput olmuyordu.)
-                dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.028 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-                    if (!g_isCursorTracking || !g_trackingStartTime || !g_fileHandle) return;
-                    NSDate *now = [NSDate date];
-                    NSTimeInterval ts = [now timeIntervalSinceDate:g_trackingStartTime] * 1000.0;
-                    NSTimeInterval unixMs = [now timeIntervalSince1970] * 1000.0;
-                    CGPoint loc = CGPointZero;
-                    CGEventRef posEv = CGEventCreate(NULL);
-                    if (posEv) {
-                        loc = CGEventGetLocation(posEv);
-                        CFRelease(posEv);
-                    }
-                    emitTextInputEvent(ts, unixMs, loc);
-                });
-                break;
             case kCGEventRightMouseDown:
             case kCGEventOtherMouseDown:
                 eventType = @"mousedown";
@@ -2027,10 +1982,6 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
             case kCGEventOtherMouseDragged:
                 eventType = @"drag";
                 break;
-            case kCGEventKeyDown:
-                // Klavye event'i — text caret tracking için
-                emitTextInputEvent(timestamp, unixTimeMs, location);
-                return event; // Mouse event olarak işleme, ayrı handle edildi
             case kCGEventMouseMoved:
             default:
                 eventType = @"move";
@@ -2040,7 +1991,7 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
         if (!ShouldEmitCursorEvent(location, cursorType, eventType)) {
             return event;
         }
-
+        
         // Cursor data oluştur
         NSDictionary *cursorInfo = @{
             @"x": @((int)location.x),
@@ -2050,7 +2001,7 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
             @"cursorType": cursorType,
             @"type": eventType
         };
-
+        
         // Direkt dosyaya yaz
         writeToFile(cursorInfo);
         RememberCursorEvent(location, cursorType, eventType);
@@ -2086,13 +2037,6 @@ void cursorTimerCallback() {
             cursorType = @"default";
         }
 
-        // Timer-only mod: CGEventTap yokken kCGEventKeyDown gelmez; caret satırları hiç yazılmazdı.
-        // I-beam görünürken AX ile periyodik textInput üret (emitTextInputEvent içinde throttle var).
-        if ([cursorType isEqualToString:@"text"] ||
-            [cursorType isEqualToString:@"vertical-text"]) {
-            emitTextInputEvent(timestamp, unixTimeMs, location);
-        }
-
         // Mouse button state polling — event tap olmadığında click/drag tespiti
         bool currentLeftMouseDown = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonLeft);
         bool currentRightMouseDown = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonRight);
@@ -2196,7 +2140,6 @@ void cleanupCursorTracking() {
     g_lastDetectedCursorType = nil;
     g_cursorTypeCounter = 0;
     g_isFirstWrite = true;
-    g_lastTextInputEmitTime = 0;
     ResetCursorEventHistory();
 }
 
@@ -2237,7 +2180,7 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
         g_trackingStartTime = [NSDate date];
         ResetCursorEventHistory();
         
-        // Create event tap for mouse + keyboard events
+        // Create event tap for mouse events
         CGEventMask eventMask = (CGEventMaskBit(kCGEventLeftMouseDown) |
                                 CGEventMaskBit(kCGEventLeftMouseUp) |
                                 CGEventMaskBit(kCGEventRightMouseDown) |
@@ -2247,8 +2190,7 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
                                 CGEventMaskBit(kCGEventMouseMoved) |
                                 CGEventMaskBit(kCGEventLeftMouseDragged) |
                                 CGEventMaskBit(kCGEventRightMouseDragged) |
-                                CGEventMaskBit(kCGEventOtherMouseDragged) |
-                                CGEventMaskBit(kCGEventKeyDown));
+                                CGEventMaskBit(kCGEventOtherMouseDragged));
         
         bool eventTapActive = false;
         g_eventTap = CGEventTapCreate(kCGSessionEventTap,
@@ -2578,33 +2520,6 @@ Napi::Value GetCursorDebugInfo(const Napi::CallbackInfo& info) {
     }
 }
 
-static Napi::Value DictToNapiTextInputSnapshot(Napi::Env env, NSDictionary *snap) {
-    Napi::Object o = Napi::Object::New(env);
-    NSNumber *cx = snap[@"caretX"];
-    NSNumber *cy = snap[@"caretY"];
-    o.Set("caretX", Napi::Number::New(env, cx ? [cx doubleValue] : 0));
-    o.Set("caretY", Napi::Number::New(env, cy ? [cy doubleValue] : 0));
-    NSDictionary *frame = snap[@"inputFrame"];
-    Napi::Object fo = Napi::Object::New(env);
-    if ([frame isKindOfClass:[NSDictionary class]]) {
-        fo.Set("x", Napi::Number::New(env, [frame[@"x"] doubleValue]));
-        fo.Set("y", Napi::Number::New(env, [frame[@"y"] doubleValue]));
-        fo.Set("width", Napi::Number::New(env, [frame[@"width"] doubleValue]));
-        fo.Set("height", Napi::Number::New(env, [frame[@"height"] doubleValue]));
-    }
-    o.Set("inputFrame", fo);
-    return o;
-}
-
-static Napi::Value GetTextInputSnapshot(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    NSDictionary *snap = MRTextInputSnapshotDictionary();
-    if (!snap) {
-        return env.Null();
-    }
-    return DictToNapiTextInputSnapshot(env, snap);
-}
-
 // Export functions
 Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports) {
     exports.Set("startCursorTracking", Napi::Function::New(env, StartCursorTracking));
@@ -2612,7 +2527,6 @@ Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports) {
     exports.Set("getCursorPosition", Napi::Function::New(env, GetCursorPosition));
     exports.Set("getCursorTrackingStatus", Napi::Function::New(env, GetCursorTrackingStatus));
     exports.Set("getCursorDebugInfo", Napi::Function::New(env, GetCursorDebugInfo));
-    exports.Set("getTextInputSnapshot", Napi::Function::New(env, GetTextInputSnapshot));
 
     return exports;
 } 

package/src/electron_safe/cursor_tracker_electron.mm

@@ -2,7 +2,6 @@
 #import <CoreGraphics/CoreGraphics.h>
 #import <AppKit/AppKit.h>
 #import "../logging.h"
-#import "../text_input_ax_snapshot.h"
 
 // Thread-safe cursor tracking for Electron
 static dispatch_queue_t g_cursorQueue = nil;
@@ -93,45 +92,12 @@ Napi::Value GetCursorPositionElectronSafe(const Napi::CallbackInfo& info) {
     }
 }
 
-static Napi::Value DictToNapiTextInputSnapshotElectron(Napi::Env env, NSDictionary *snap) {
-    Napi::Object o = Napi::Object::New(env);
-    NSNumber *cx = snap[@"caretX"];
-    NSNumber *cy = snap[@"caretY"];
-    o.Set("caretX", Napi::Number::New(env, cx ? [cx doubleValue] : 0));
-    o.Set("caretY", Napi::Number::New(env, cy ? [cy doubleValue] : 0));
-    NSDictionary *frame = snap[@"inputFrame"];
-    Napi::Object fo = Napi::Object::New(env);
-    if ([frame isKindOfClass:[NSDictionary class]]) {
-        fo.Set("x", Napi::Number::New(env, [frame[@"x"] doubleValue]));
-        fo.Set("y", Napi::Number::New(env, [frame[@"y"] doubleValue]));
-        fo.Set("width", Napi::Number::New(env, [frame[@"width"] doubleValue]));
-        fo.Set("height", Napi::Number::New(env, [frame[@"height"] doubleValue]));
-    }
-    o.Set("inputFrame", fo);
-    return o;
-}
-
-Napi::Value GetTextInputSnapshotElectronSafe(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    @try {
-        NSDictionary *snap = MRTextInputSnapshotDictionary();
-        if (!snap) {
-            return env.Null();
-        }
-        return DictToNapiTextInputSnapshotElectron(env, snap);
-    } @catch (NSException *e) {
-        NSLog(@"❌ getTextInputSnapshot: %@", e.reason);
-        return env.Null();
-    }
-}
-
 // Initialize cursor tracker module
 Napi::Object InitCursorTrackerElectron(Napi::Env env, Napi::Object exports) {
     @try {
         initializeCursorQueue();
         
         exports.Set("getCursorPosition", Napi::Function::New(env, GetCursorPositionElectronSafe));
-        exports.Set("getTextInputSnapshot", Napi::Function::New(env, GetTextInputSnapshotElectronSafe));
         
         MRLog(@"✅ Electron-safe cursor tracker initialized");
         return exports;

package/src/electron_safe/window_selector_electron.mm

@@ -13,9 +13,12 @@ static void initializeWindowQueue() {
 }
 
 static BOOL ShouldAllowElectronWindows(void) {
-    NSString *flag = [[[NSProcessInfo processInfo] environment] objectForKey:@"CREAVIT_ALLOW_ELECTRON_WINDOWS"];
-    if (!flag) return NO;
+    // NSProcessInfo.environment snapshot'lanır ve runtime'da process.env değişikliklerini yansıtmaz.
+    // getenv() libc üzerinden her seferinde güncel değeri okur — menüden toggle'lanabilsin diye.
+    const char *raw = getenv("CREAVIT_ALLOW_ELECTRON_WINDOWS");
+    if (!raw) return NO;
 
+    NSString *flag = [NSString stringWithUTF8String:raw];
     NSString *normalized = [[flag lowercaseString] stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
     return [normalized isEqualToString:@"1"] ||
            [normalized isEqualToString:@"true"] ||