node-mac-recorder 1.1.0 → 1.2.1

package/README.md

@@ -11,6 +11,7 @@ A powerful native macOS screen recording Node.js package with advanced window se
 - 🎯 **Area Selection** - Record custom screen regions
 - 🖱️ **Multi-Display Support** - Automatic display detection and selection
 - 🎨 **Cursor Control** - Toggle cursor visibility in recordings
+- 🖱️ **Cursor Tracking** - Track mouse position, cursor types, and click events
 
 🎵 **Granular Audio Controls**
 
@@ -231,6 +232,64 @@ const thumbnail = await recorder.getDisplayThumbnail(0, {
 // Perfect for display selection UI
 ```
 
+### Cursor Tracking Methods
+
+#### `startCursorTracking(outputPath)`
+
+Starts tracking cursor movements and saves data to JSON file.
+
+```javascript
+await recorder.startCursorTracking("./cursor-data.json");
+// Cursor tracking started - will record position, cursor type, and events
+```
+
+#### `stopCursorTracking()`
+
+Stops cursor tracking and saves collected data.
+
+```javascript
+await recorder.stopCursorTracking();
+// Data saved to specified JSON file
+```
+
+#### `getCursorPosition()`
+
+Gets current cursor position and type.
+
+```javascript
+const position = recorder.getCursorPosition();
+console.log(position);
+// {
+//   x: 1234,
+//   y: 567,
+//   cursorType: "default" // "default", "pointer", "grabbing", "text"
+// }
+```
+
+#### `getCursorTrackingStatus()`
+
+Returns cursor tracking status and data count.
+
+```javascript
+const status = recorder.getCursorTrackingStatus();
+console.log(status);
+// {
+//   isTracking: true,
+//   dataCount: 1250,
+//   hasEventTap: true,
+//   hasRunLoopSource: true
+// }
+```
+
+#### `saveCursorData(outputPath)`
+
+Manually saves current cursor data to file.
+
+```javascript
+await recorder.saveCursorData("./cursor-backup.json");
+// Data saved to file
+```
+
 ## Usage Examples
 
 ### Window-Specific Recording
@@ -404,6 +463,99 @@ async function createDisplaySelector() {
 }
 ```
 
+### Cursor Tracking Usage
+
+```javascript
+const recorder = new MacRecorder();
+
+async function trackUserInteraction() {
+	// Start cursor tracking
+	await recorder.startCursorTracking("./user-interactions.json");
+	console.log("Cursor tracking started...");
+
+	// Monitor real-time cursor position
+	const monitorInterval = setInterval(() => {
+		const position = recorder.getCursorPosition();
+		console.log(
+			`Cursor: ${position.x}, ${position.y} (${position.cursorType})`
+		);
+
+		const status = recorder.getCursorTrackingStatus();
+		console.log(`Tracking status: ${status.dataCount} positions recorded`);
+	}, 100); // Check every 100ms
+
+	// Track for 10 seconds
+	setTimeout(async () => {
+		clearInterval(monitorInterval);
+
+		// Stop tracking and save data
+		await recorder.stopCursorTracking();
+		console.log("Cursor tracking completed!");
+
+		// Load and analyze the data
+		const fs = require("fs");
+		const data = JSON.parse(
+			fs.readFileSync("./user-interactions.json", "utf8")
+		);
+
+		console.log(`Total interactions recorded: ${data.length}`);
+
+		// Analyze cursor types
+		const cursorTypes = {};
+		data.forEach((item) => {
+			cursorTypes[item.cursorType] = (cursorTypes[item.cursorType] || 0) + 1;
+		});
+
+		console.log("Cursor types distribution:", cursorTypes);
+
+		// Analyze event types
+		const eventTypes = {};
+		data.forEach((item) => {
+			eventTypes[item.type] = (eventTypes[item.type] || 0) + 1;
+		});
+
+		console.log("Event types distribution:", eventTypes);
+	}, 10000);
+}
+
+trackUserInteraction();
+```
+
+### Combined Screen Recording + Cursor Tracking
+
+```javascript
+const recorder = new MacRecorder();
+
+async function recordWithCursorTracking() {
+	// Start both screen recording and cursor tracking
+	await Promise.all([
+		recorder.startRecording("./screen-recording.mov", {
+			captureCursor: false, // Don't show cursor in video
+			includeSystemAudio: true,
+			quality: "high",
+		}),
+		recorder.startCursorTracking("./cursor-data.json"),
+	]);
+
+	console.log("Recording screen and tracking cursor...");
+
+	// Record for 30 seconds
+	setTimeout(async () => {
+		await Promise.all([
+			recorder.stopRecording(),
+			recorder.stopCursorTracking(),
+		]);
+
+		console.log("Screen recording and cursor tracking completed!");
+		console.log("Files created:");
+		console.log("- screen-recording.mov");
+		console.log("- cursor-data.json");
+	}, 30000);
+}
+
+recordWithCursorTracking();
+```
+
 ## Integration Examples
 
 ### Electron Integration
@@ -577,6 +729,7 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ### Latest Updates
 
+- ✅ **Cursor Tracking**: Track mouse position, cursor types, and click events with JSON export
 - ✅ **Window Recording**: Automatic coordinate conversion for multi-display setups
 - ✅ **Audio Controls**: Separate microphone and system audio controls
 - ✅ **Display Selection**: Multi-monitor support with automatic detection

package/binding.gyp

@@ -5,7 +5,8 @@
       "sources": [
         "src/mac_recorder.mm",
         "src/screen_capture.mm",
-        "src/audio_capture.mm"
+        "src/audio_capture.mm",
+        "src/cursor_tracker.mm"
       ],
       "include_dirs": [
         "<!@(node -p \"require('node-addon-api').include\")"
@@ -30,7 +31,10 @@
           "-framework CoreVideo",
           "-framework Foundation",
           "-framework AppKit",
-          "-framework ScreenCaptureKit"
+          "-framework ScreenCaptureKit",
+          "-framework ApplicationServices",
+          "-framework Carbon",
+          "-framework Accessibility"
         ]
       },
       "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ]

package/cursor-data.json

@@ -0,0 +1,93 @@
+[
+	{
+		"x": 1119,
+		"y": 1090,
+		"timestamp": 106,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1119,
+		"y": 1080,
+		"timestamp": 407,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1119,
+		"y": 1066,
+		"timestamp": 423,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1119,
+		"y": 1042,
+		"timestamp": 446,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1119,
+		"y": 968,
+		"timestamp": 466,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1129,
+		"y": 906,
+		"timestamp": 487,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1153,
+		"y": 820,
+		"timestamp": 507,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1168,
+		"y": 782,
+		"timestamp": 528,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 549,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 2578,
+		"cursorType": "default",
+		"type": "mousedown"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 2599,
+		"cursorType": "default",
+		"type": "move"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 2724,
+		"cursorType": "default",
+		"type": "mouseup"
+	},
+	{
+		"x": 1176,
+		"y": 764,
+		"timestamp": 2744,
+		"cursorType": "default",
+		"type": "move"
+	}
+]

package/cursor-test.js

@@ -0,0 +1,50 @@
+const MacRecorder = require("./index");
+const path = require("path");
+const fs = require("fs");
+
+async function testCursorCapture() {
+	console.log("🎯 Cursor Capture Demo\n");
+
+	const recorder = new MacRecorder();
+	const outputPath = path.join(__dirname, "cursor-data.json");
+
+	try {
+		// Başlat
+		await recorder.startCursorCapture(outputPath);
+		console.log("✅ Kayıt başladı...");
+
+		// 5 saniye bekle
+		console.log("📱 5 saniye hareket ettirin, tıklayın...");
+
+		for (let i = 5; i > 0; i--) {
+			process.stdout.write(`⏳ ${i}... `);
+			await new Promise((resolve) => setTimeout(resolve, 1000));
+		}
+		console.log("\n");
+
+		// Durdur
+		await recorder.stopCursorCapture();
+		console.log("✅ Kayıt tamamlandı!");
+
+		// Sonuç
+		if (fs.existsSync(outputPath)) {
+			const data = JSON.parse(fs.readFileSync(outputPath, "utf8"));
+			console.log(`📄 ${data.length} event kaydedildi -> ${outputPath}`);
+
+			// Basit istatistik
+			const clicks = data.filter((d) => d.type === "mousedown").length;
+			if (clicks > 0) {
+				console.log(`🖱️  ${clicks} click algılandı`);
+			}
+		}
+	} catch (error) {
+		console.error("❌ Hata:", error.message);
+	}
+}
+
+// Direkt çalıştır
+if (require.main === module) {
+	testCursorCapture().catch(console.error);
+}
+
+module.exports = { testCursorCapture };

package/index.js

@@ -25,6 +25,14 @@ class MacRecorder extends EventEmitter {
 		this.outputPath = null;
 		this.recordingTimer = null;
 		this.recordingStartTime = null;
+
+		// Cursor capture variables
+		this.cursorCaptureInterval = null;
+		this.cursorCaptureFile = null;
+		this.cursorCaptureStartTime = null;
+		this.cursorCaptureFirstWrite = true;
+		this.lastCapturedData = null;
+
 		this.options = {
 			includeMicrophone: false, // Default olarak mikrofon kapalı
 			includeSystemAudio: true, // Default olarak sistem sesi açık
@@ -413,6 +421,159 @@ 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;
+	}
+
+	/**
+	 * Cursor capture başlatır - otomatik olarak dosyaya yazmaya başlar
+	 */
+	async startCursorCapture(filepath) {
+		if (!filepath) {
+			throw new Error("File path is required");
+		}
+
+		if (this.cursorCaptureInterval) {
+			throw new Error("Cursor capture is already running");
+		}
+
+		return new Promise((resolve, reject) => {
+			try {
+				// Dosyayı oluştur ve temizle
+				const fs = require("fs");
+				fs.writeFileSync(filepath, "[");
+
+				this.cursorCaptureFile = filepath;
+				this.cursorCaptureStartTime = Date.now();
+				this.cursorCaptureFirstWrite = true;
+				this.lastCapturedData = null;
+
+				// 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;
+
+						const cursorData = {
+							x: position.x,
+							y: position.y,
+							timestamp: timestamp,
+							cursorType: position.cursorType,
+							type: position.eventType || "move",
+						};
+
+						// 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);
+					}
+				}, 20); // 50 FPS - mouse event'leri yakalamak için daha hızlı
+
+				this.emit("cursorCaptureStarted", filepath);
+				resolve(true);
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+
+	/**
+	 * Cursor capture durdurur - dosya yazma işlemini sonlandırır
+	 */
+	async stopCursorCapture() {
+		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.emit("cursorCaptureStopped");
+				resolve(true);
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+
+	/**
+	 * Anlık cursor pozisyonunu ve tipini döndürür
+	 */
+	getCursorPosition() {
+		try {
+			return nativeBinding.getCursorPosition();
+		} catch (error) {
+			throw new Error("Failed to get cursor position: " + error.message);
+		}
+	}
+
+	/**
+	 * Cursor capture durumunu döndürür
+	 */
+	getCursorCaptureStatus() {
+		return {
+			isCapturing: !!this.cursorCaptureInterval,
+			outputFile: this.cursorCaptureFile || null,
+			startTime: this.cursorCaptureStartTime || null,
+		};
+	}
+
 	/**
 	 * Native modül bilgilerini döndürür
 	 */

package/package.json

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

package/src/cursor_tracker.mm

@@ -0,0 +1,457 @@
+#import <napi.h>
+#import <AppKit/AppKit.h>
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <ApplicationServices/ApplicationServices.h>
+#import <Carbon/Carbon.h>
+#import <Accessibility/Accessibility.h>
+
+// Global state for cursor tracking
+static bool g_isCursorTracking = false;
+static CFMachPortRef g_eventTap = NULL;
+static CFRunLoopSourceRef g_runLoopSource = NULL;
+static NSDate *g_trackingStartTime = nil;
+static NSString *g_outputPath = nil;
+static NSTimer *g_cursorTimer = nil;
+static int g_debugCallbackCount = 0;
+static NSFileHandle *g_fileHandle = nil;
+static bool g_isFirstWrite = true;
+
+// Forward declaration
+void cursorTimerCallback();
+void writeToFile(NSDictionary *cursorData);
+
+// Timer helper class
+@interface CursorTimerTarget : NSObject
+- (void)timerCallback:(NSTimer *)timer;
+@end
+
+@implementation CursorTimerTarget
+- (void)timerCallback:(NSTimer *)timer {
+    cursorTimerCallback();
+}
+@end
+
+static CursorTimerTarget *g_timerTarget = nil;
+
+// Global cursor state tracking
+static NSString *g_lastDetectedCursorType = nil;
+static int g_cursorTypeCounter = 0;
+
+// Mouse button state tracking
+static bool g_leftMouseDown = false;
+static bool g_rightMouseDown = false;
+static NSString *g_lastEventType = @"move";
+
+// Cursor type detection helper - gerçek cursor type'ı al
+NSString* getCursorType() {
+    @autoreleasepool {
+        g_cursorTypeCounter++;
+        
+        @try {
+            // NSCursor.currentCursor kullanarak gerçek cursor type'ı al
+            NSCursor *currentCursor = [NSCursor currentCursor];
+            
+            if (currentCursor == [NSCursor arrowCursor]) {
+                g_lastDetectedCursorType = @"default";
+                return @"default";
+            } else if (currentCursor == [NSCursor pointingHandCursor]) {
+                g_lastDetectedCursorType = @"pointer";
+                return @"pointer";
+            } else if (currentCursor == [NSCursor IBeamCursor]) {
+                g_lastDetectedCursorType = @"text";
+                return @"text";
+            } else if (currentCursor == [NSCursor openHandCursor]) {
+                g_lastDetectedCursorType = @"grab";
+                return @"grab";
+            } else if (currentCursor == [NSCursor closedHandCursor]) {
+                g_lastDetectedCursorType = @"grabbing";
+                return @"grabbing";
+            } else if (currentCursor == [NSCursor resizeLeftRightCursor]) {
+                g_lastDetectedCursorType = @"ew-resize";
+                return @"ew-resize";
+            } else if (currentCursor == [NSCursor resizeUpDownCursor]) {
+                g_lastDetectedCursorType = @"ns-resize";
+                return @"ns-resize";
+            } else if (currentCursor == [NSCursor crosshairCursor]) {
+                g_lastDetectedCursorType = @"crosshair";
+                return @"crosshair";
+            } else {
+                // Bilinmeyen cursor - default olarak dön
+                g_lastDetectedCursorType = @"default";
+                return @"default";
+            }
+        } @catch (NSException *exception) {
+            // Hata durumunda default dön
+            g_lastDetectedCursorType = @"default";
+            return @"default";
+        }
+    }
+}
+
+// Dosyaya yazma helper fonksiyonu
+void writeToFile(NSDictionary *cursorData) {
+    @autoreleasepool {
+        if (!g_fileHandle || !cursorData) {
+            return;
+        }
+        
+        @try {
+            NSError *error;
+            NSData *jsonData = [NSJSONSerialization dataWithJSONObject:cursorData
+                                                               options:0
+                                                                 error:&error];
+            if (jsonData && !error) {
+                NSString *jsonString = [[[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding] autorelease];
+                
+                if (g_isFirstWrite) {
+                    // İlk yazma - array başlat
+                    [g_fileHandle writeData:[@"[" dataUsingEncoding:NSUTF8StringEncoding]];
+                    [g_fileHandle writeData:[jsonString dataUsingEncoding:NSUTF8StringEncoding]];
+                    g_isFirstWrite = false;
+                } else {
+                    // Sonraki yazmalar - virgül + json
+                    [g_fileHandle writeData:[@"," dataUsingEncoding:NSUTF8StringEncoding]];
+                    [g_fileHandle writeData:[jsonString dataUsingEncoding:NSUTF8StringEncoding]];
+                }
+                
+                [g_fileHandle synchronizeFile];
+            }
+        } @catch (NSException *exception) {
+            // Hata durumunda sessizce devam et
+        }
+    }
+}
+
+// Event callback for mouse events
+CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon) {
+    @autoreleasepool {
+        g_debugCallbackCount++; // Callback çağrıldığını say
+        
+        if (!g_isCursorTracking || !g_trackingStartTime || !g_fileHandle) {
+            return event;
+        }
+        
+        CGPoint location = CGEventGetLocation(event);
+        NSTimeInterval timestamp = [[NSDate date] timeIntervalSinceDate:g_trackingStartTime] * 1000; // milliseconds
+        NSString *cursorType = getCursorType();
+        NSString *eventType = @"move";
+        
+        // Event tipini belirle
+        switch (type) {
+            case kCGEventLeftMouseDown:
+            case kCGEventRightMouseDown:
+            case kCGEventOtherMouseDown:
+                eventType = @"mousedown";
+                break;
+            case kCGEventLeftMouseUp:
+            case kCGEventRightMouseUp:
+            case kCGEventOtherMouseUp:
+                eventType = @"mouseup";
+                break;
+            case kCGEventLeftMouseDragged:
+            case kCGEventRightMouseDragged:
+            case kCGEventOtherMouseDragged:
+                eventType = @"drag";
+                break;
+            case kCGEventMouseMoved:
+            default:
+                eventType = @"move";
+                break;
+        }
+        
+        // Cursor data oluştur
+        NSDictionary *cursorInfo = @{
+            @"x": @((int)location.x),
+            @"y": @((int)location.y),
+            @"timestamp": @((int)timestamp),
+            @"cursorType": cursorType,
+            @"type": eventType
+        };
+        
+        // Direkt dosyaya yaz
+        writeToFile(cursorInfo);
+        
+        return event;
+    }
+}
+
+// Timer callback for periodic cursor position updates
+void cursorTimerCallback() {
+    @autoreleasepool {
+        g_debugCallbackCount++; // Timer callback çağrıldığını say
+        
+        if (!g_isCursorTracking || !g_trackingStartTime || !g_fileHandle) {
+            return;
+        }
+        
+        // Ana thread'de mouse pozisyonu al
+        __block NSPoint mouseLocation;
+        __block CGPoint location;
+        
+        if ([NSThread isMainThread]) {
+            mouseLocation = [NSEvent mouseLocation];
+        } else {
+            dispatch_sync(dispatch_get_main_queue(), ^{
+                mouseLocation = [NSEvent mouseLocation];
+            });
+        }
+        
+        CGDirectDisplayID mainDisplay = CGMainDisplayID();
+        size_t displayHeight = CGDisplayPixelsHigh(mainDisplay);
+        location = CGPointMake(mouseLocation.x, displayHeight - mouseLocation.y);
+        
+        NSTimeInterval timestamp = [[NSDate date] timeIntervalSinceDate:g_trackingStartTime] * 1000; // milliseconds
+        NSString *cursorType = getCursorType();
+        
+        // Cursor data oluştur
+        NSDictionary *cursorInfo = @{
+            @"x": @((int)location.x),
+            @"y": @((int)location.y),
+            @"timestamp": @((int)timestamp),
+            @"cursorType": cursorType,
+            @"type": @"move"
+        };
+        
+        // Direkt dosyaya yaz
+        writeToFile(cursorInfo);
+    }
+}
+
+// Helper function to cleanup cursor tracking
+void cleanupCursorTracking() {
+    g_isCursorTracking = false;
+    
+    // Timer temizle
+    if (g_cursorTimer) {
+        [g_cursorTimer invalidate];
+        g_cursorTimer = nil;
+    }
+    
+    if (g_timerTarget) {
+        [g_timerTarget autorelease];
+        g_timerTarget = nil;
+    }
+    
+    // Dosyayı önce kapat (en önemli işlem)
+    if (g_fileHandle) {
+        @try {
+            if (g_isFirstWrite) {
+                // Hiç veri yazılmamışsa boş array
+                [g_fileHandle writeData:[@"[]" dataUsingEncoding:NSUTF8StringEncoding]];
+            } else {
+                // JSON array'i kapat
+                [g_fileHandle writeData:[@"]" dataUsingEncoding:NSUTF8StringEncoding]];
+            }
+            [g_fileHandle synchronizeFile];
+            [g_fileHandle closeFile];
+        } @catch (NSException *exception) {
+            // Dosya işlemi hata verirse sessizce devam et
+        }
+        g_fileHandle = nil;
+    }
+    
+    // Event tap'i durdur (non-blocking)
+    if (g_eventTap) {
+        CGEventTapEnable(g_eventTap, false);
+        g_eventTap = NULL; // CFRelease işlemini yapmıyoruz - system handle etsin
+    }
+    
+    // Run loop source'unu kaldır (non-blocking)
+    if (g_runLoopSource) {
+        g_runLoopSource = NULL; // CFRelease işlemini yapmıyoruz
+    }
+    
+    // Global değişkenleri sıfırla
+    g_trackingStartTime = nil;
+    g_outputPath = nil;
+    g_debugCallbackCount = 0;
+    g_lastDetectedCursorType = nil;
+    g_cursorTypeCounter = 0;
+    g_isFirstWrite = true;
+}
+
+// NAPI Function: Start Cursor Tracking
+Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Output path required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    
+    if (g_isCursorTracking) {
+        return Napi::Boolean::New(env, false);
+    }
+    
+    std::string outputPath = info[0].As<Napi::String>().Utf8Value();
+    
+    @try {
+        // Dosyayı oluştur ve aç
+        g_outputPath = [NSString stringWithUTF8String:outputPath.c_str()];
+        g_fileHandle = [[NSFileHandle fileHandleForWritingAtPath:g_outputPath] retain];
+        
+        if (!g_fileHandle) {
+            // Dosya yoksa oluştur
+            [[NSFileManager defaultManager] createFileAtPath:g_outputPath contents:nil attributes:nil];
+            g_fileHandle = [[NSFileHandle fileHandleForWritingAtPath:g_outputPath] retain];
+        }
+        
+        if (!g_fileHandle) {
+            return Napi::Boolean::New(env, false);
+        }
+        
+        // Dosyayı temizle (baştan başla)
+        [g_fileHandle truncateFileAtOffset:0];
+        g_isFirstWrite = true;
+        
+        g_trackingStartTime = [NSDate date];
+        
+        // Create event tap for mouse events
+        CGEventMask eventMask = (CGEventMaskBit(kCGEventLeftMouseDown) |
+                                CGEventMaskBit(kCGEventLeftMouseUp) |
+                                CGEventMaskBit(kCGEventRightMouseDown) |
+                                CGEventMaskBit(kCGEventRightMouseUp) |
+                                CGEventMaskBit(kCGEventOtherMouseDown) |
+                                CGEventMaskBit(kCGEventOtherMouseUp) |
+                                CGEventMaskBit(kCGEventMouseMoved) |
+                                CGEventMaskBit(kCGEventLeftMouseDragged) |
+                                CGEventMaskBit(kCGEventRightMouseDragged) |
+                                CGEventMaskBit(kCGEventOtherMouseDragged));
+        
+        g_eventTap = CGEventTapCreate(kCGSessionEventTap,
+                                     kCGHeadInsertEventTap,
+                                     kCGEventTapOptionListenOnly,
+                                     eventMask,
+                                     eventCallback,
+                                     NULL);
+        
+        if (g_eventTap) {
+            // Event tap başarılı - detaylı event tracking aktif
+            g_runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, g_eventTap, 0);
+            CFRunLoopAddSource(CFRunLoopGetMain(), g_runLoopSource, kCFRunLoopCommonModes);
+            CGEventTapEnable(g_eventTap, true);
+        }
+        
+        // NSTimer kullan (main thread'de çalışır)
+        g_timerTarget = [[CursorTimerTarget alloc] init];
+        
+        g_cursorTimer = [NSTimer timerWithTimeInterval:0.05 // 50ms (20 FPS)
+                                                target:g_timerTarget
+                                              selector:@selector(timerCallback:)
+                                              userInfo:nil
+                                               repeats:YES];
+        
+        // Main run loop'a ekle
+        [[NSRunLoop mainRunLoop] addTimer:g_cursorTimer forMode:NSRunLoopCommonModes];
+        
+        g_isCursorTracking = true;
+        return Napi::Boolean::New(env, true);
+        
+    } @catch (NSException *exception) {
+        cleanupCursorTracking();
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// NAPI Function: Stop Cursor Tracking
+Napi::Value StopCursorTracking(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (!g_isCursorTracking) {
+        return Napi::Boolean::New(env, false);
+    }
+    
+    @try {
+        cleanupCursorTracking();
+        return Napi::Boolean::New(env, true);
+        
+    } @catch (NSException *exception) {
+        cleanupCursorTracking();
+        return Napi::Boolean::New(env, false);
+    }
+}
+
+// NAPI Function: Get Current Cursor Position
+Napi::Value GetCursorPosition(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    @try {
+        // NSEvent kullanarak mouse pozisyonu al (daha güvenli)
+        NSPoint mouseLocation = [NSEvent mouseLocation];
+        
+        // CGDisplayPixelsHigh ve CGDisplayPixelsWide ile koordinat dönüşümü
+        CGDirectDisplayID mainDisplay = CGMainDisplayID();
+        size_t displayHeight = CGDisplayPixelsHigh(mainDisplay);
+        
+        // macOS coordinate system (bottom-left origin) to screen coordinates (top-left origin)
+        CGPoint location = CGPointMake(mouseLocation.x, displayHeight - mouseLocation.y);
+        
+        NSString *cursorType = getCursorType();
+        
+        // Mouse button state'ini kontrol et
+        bool currentLeftMouseDown = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonLeft);
+        bool currentRightMouseDown = CGEventSourceButtonState(kCGEventSourceStateHIDSystemState, kCGMouseButtonRight);
+        
+        NSString *eventType = @"move";
+        
+        // Mouse button state değişikliklerini tespit et
+        if (currentLeftMouseDown && !g_leftMouseDown) {
+            eventType = @"mousedown";
+            g_lastEventType = @"mousedown";
+        } else if (!currentLeftMouseDown && g_leftMouseDown) {
+            eventType = @"mouseup";
+            g_lastEventType = @"mouseup";
+        } else if (currentRightMouseDown && !g_rightMouseDown) {
+            eventType = @"rightmousedown";
+            g_lastEventType = @"rightmousedown";
+        } else if (!currentRightMouseDown && g_rightMouseDown) {
+            eventType = @"rightmouseup";
+            g_lastEventType = @"rightmouseup";
+        } else {
+            eventType = @"move";
+            g_lastEventType = @"move";
+        }
+        
+        // State'i güncelle
+        g_leftMouseDown = currentLeftMouseDown;
+        g_rightMouseDown = currentRightMouseDown;
+        
+        Napi::Object result = Napi::Object::New(env);
+        result.Set("x", Napi::Number::New(env, (int)location.x));
+        result.Set("y", Napi::Number::New(env, (int)location.y));
+        result.Set("cursorType", Napi::String::New(env, [cursorType UTF8String]));
+        result.Set("eventType", Napi::String::New(env, [eventType UTF8String]));
+        
+        return result;
+        
+    } @catch (NSException *exception) {
+        return env.Null();
+    }
+}
+
+// NAPI Function: Get Cursor Tracking Status
+Napi::Value GetCursorTrackingStatus(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    Napi::Object result = Napi::Object::New(env);
+    result.Set("isTracking", Napi::Boolean::New(env, g_isCursorTracking));
+    result.Set("hasEventTap", Napi::Boolean::New(env, g_eventTap != NULL));
+    result.Set("hasRunLoopSource", Napi::Boolean::New(env, g_runLoopSource != NULL));
+    result.Set("hasFileHandle", Napi::Boolean::New(env, g_fileHandle != NULL));
+    result.Set("hasTimer", Napi::Boolean::New(env, g_cursorTimer != NULL));
+    result.Set("debugCallbackCount", Napi::Number::New(env, g_debugCallbackCount));
+    result.Set("cursorTypeCounter", Napi::Number::New(env, g_cursorTypeCounter));
+    
+    return result;
+}
+
+// Export functions
+Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports) {
+    exports.Set("startCursorTracking", Napi::Function::New(env, StartCursorTracking));
+    exports.Set("stopCursorTracking", Napi::Function::New(env, StopCursorTracking));
+    exports.Set("getCursorPosition", Napi::Function::New(env, GetCursorPosition));
+    exports.Set("getCursorTrackingStatus", Napi::Function::New(env, GetCursorTrackingStatus));
+    
+    return exports;
+} 

package/src/mac_recorder.mm

@@ -7,6 +7,9 @@
 #import <ImageIO/ImageIO.h>
 #import <CoreAudio/CoreAudio.h>
 
+// Cursor tracker function declarations
+Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports);
+
 @interface MacRecorderDelegate : NSObject <AVCaptureFileOutputRecordingDelegate>
 @property (nonatomic, copy) void (^completionHandler)(NSURL *outputURL, NSError *error);
 @end
@@ -659,6 +662,9 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set(Napi::String::New(env, "getWindowThumbnail"), Napi::Function::New(env, GetWindowThumbnail));
     exports.Set(Napi::String::New(env, "getDisplayThumbnail"), Napi::Function::New(env, GetDisplayThumbnail));
     
+    // Initialize cursor tracker
+    InitCursorTracker(env, exports);
+    
     return exports;
 }
 

package/preview-test.js

@@ -1,329 +0,0 @@
-const MacRecorder = require("./index.js");
-const fs = require("fs");
-
-async function testPreviews() {
-	const recorder = new MacRecorder();
-
-	console.log("🖼️ Thumbnail Preview Test\n");
-
-	try {
-		// 1. Display Previews
-		console.log("📺 Display Thumbnails Test...");
-		const displays = await recorder.getDisplays();
-
-		console.log(`Found ${displays.length} displays:`);
-		for (let i = 0; i < displays.length; i++) {
-			const display = displays[i];
-			console.log(
-				`  Display ${i}: ${display.resolution} ${
-					display.isPrimary ? "(Primary)" : ""
-				}`
-			);
-
-			try {
-				console.log(`  📸 Capturing thumbnail...`);
-				const thumbnail = await recorder.getDisplayThumbnail(display.id, {
-					maxWidth: 300,
-					maxHeight: 200,
-				});
-
-				console.log(`  ✅ Success: ${thumbnail.length} chars`);
-
-				// Save as HTML file to view
-				const htmlContent = `
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Display ${i} Preview</title>
-    <style>
-        body { 
-            font-family: Arial, sans-serif; 
-            text-align: center; 
-            padding: 20px; 
-            background: #f5f5f5;
-        }
-        .preview-card {
-            background: white;
-            padding: 20px;
-            border-radius: 12px;
-            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
-            max-width: 400px;
-            margin: 0 auto;
-        }
-        img { 
-            border: 2px solid #007AFF; 
-            border-radius: 8px; 
-            max-width: 100%;
-        }
-        .info { 
-            background: #f0f0f0; 
-            padding: 15px; 
-            border-radius: 8px; 
-            margin: 15px 0;
-            text-align: left;
-        }
-        h1 { color: #007AFF; }
-    </style>
-</head>
-<body>
-    <div class="preview-card">
-        <h1>📺 Display ${i} Preview</h1>
-        <div class="info">
-            <strong>Resolution:</strong> ${display.resolution}<br>
-            <strong>Position:</strong> (${display.x}, ${display.y})<br>
-            <strong>Primary:</strong> ${display.isPrimary ? "Yes" : "No"}<br>
-            <strong>Display ID:</strong> ${display.id}
-        </div>
-        <img src="${thumbnail}" alt="Display ${i} Preview" />
-        <p><small>Captured: ${new Date().toLocaleString()}</small></p>
-    </div>
-</body>
-</html>`;
-
-				fs.writeFileSync(`display-${i}-preview.html`, htmlContent);
-				console.log(`  💾 Saved: display-${i}-preview.html\n`);
-			} catch (error) {
-				console.log(`  ❌ Failed: ${error.message}\n`);
-			}
-		}
-
-		// 2. Window Previews
-		console.log("🪟 Window Thumbnails Test...");
-		const windows = await recorder.getWindows();
-
-		// Test first 3 windows
-		const testWindows = windows.slice(0, 3);
-		console.log(`Testing ${testWindows.length} windows:`);
-
-		for (let i = 0; i < testWindows.length; i++) {
-			const window = testWindows[i];
-			console.log(`  Window ${i}: [${window.appName}] ${window.name}`);
-			console.log(`  Size: ${window.width}x${window.height}`);
-
-			try {
-				console.log(`  📸 Capturing thumbnail...`);
-				const thumbnail = await recorder.getWindowThumbnail(window.id, {
-					maxWidth: 300,
-					maxHeight: 200,
-				});
-
-				console.log(`  ✅ Success: ${thumbnail.length} chars`);
-
-				// Save as HTML file to view
-				const htmlContent = `
-<!DOCTYPE html>
-<html>
-<head>
-    <title>${window.appName} Preview</title>
-    <style>
-        body { 
-            font-family: Arial, sans-serif; 
-            text-align: center; 
-            padding: 20px; 
-            background: #f5f5f5;
-        }
-        .preview-card {
-            background: white;
-            padding: 20px;
-            border-radius: 12px;
-            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
-            max-width: 400px;
-            margin: 0 auto;
-        }
-        img { 
-            border: 2px solid #FF3B30; 
-            border-radius: 8px; 
-            max-width: 100%;
-        }
-        .info { 
-            background: #f0f0f0; 
-            padding: 15px; 
-            border-radius: 8px; 
-            margin: 15px 0;
-            text-align: left;
-        }
-        h1 { color: #FF3B30; }
-        .app-name { color: #007AFF; font-weight: bold; }
-    </style>
-</head>
-<body>
-    <div class="preview-card">
-        <h1>🪟 <span class="app-name">${window.appName}</span></h1>
-        <div class="info">
-            <strong>Window:</strong> ${window.name}<br>
-            <strong>Size:</strong> ${window.width}x${window.height}<br>
-            <strong>Position:</strong> (${window.x}, ${window.y})<br>
-            <strong>Window ID:</strong> ${window.id}
-        </div>
-        <img src="${thumbnail}" alt="${window.appName} Preview" />
-        <p><small>Captured: ${new Date().toLocaleString()}</small></p>
-    </div>
-</body>
-</html>`;
-
-				const fileName = `window-${window.appName.replace(
-					/[^a-zA-Z0-9]/g,
-					""
-				)}-${i}-preview.html`;
-				fs.writeFileSync(fileName, htmlContent);
-				console.log(`  💾 Saved: ${fileName}\n`);
-			} catch (error) {
-				console.log(`  ❌ Failed: ${error.message}\n`);
-			}
-		}
-
-		// 3. Create Gallery
-		console.log("🎨 Creating Preview Gallery...");
-		const previewFiles = fs
-			.readdirSync(".")
-			.filter((file) => file.endsWith("-preview.html"))
-			.sort();
-
-		if (previewFiles.length > 0) {
-			const galleryContent = `
-<!DOCTYPE html>
-<html>
-<head>
-    <title>📸 Thumbnail Preview Gallery</title>
-    <style>
-        body { 
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; 
-            padding: 20px; 
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            min-height: 100vh;
-        }
-        .header {
-            text-align: center;
-            margin-bottom: 30px;
-        }
-        .gallery { 
-            display: grid; 
-            grid-template-columns: repeat(auto-fit, minmax(350px, 1fr)); 
-            gap: 20px; 
-            margin-top: 20px;
-        }
-        .preview-card {
-            background: rgba(255,255,255,0.1);
-            border-radius: 16px;
-            overflow: hidden;
-            backdrop-filter: blur(10px);
-            border: 1px solid rgba(255,255,255,0.2);
-            transition: transform 0.3s ease;
-        }
-        .preview-card:hover {
-            transform: translateY(-8px);
-        }
-        .card-header {
-            padding: 20px;
-            border-bottom: 1px solid rgba(255,255,255,0.1);
-        }
-        .card-title {
-            margin: 0;
-            font-size: 18px;
-            font-weight: 600;
-        }
-        .card-subtitle {
-            margin: 8px 0 0 0;
-            opacity: 0.8;
-            font-size: 14px;
-        }
-        iframe {
-            width: 100%;
-            height: 400px;
-            border: none;
-            background: white;
-        }
-        .stats {
-            background: rgba(255,255,255,0.2);
-            padding: 20px;
-            border-radius: 12px;
-            text-align: center;
-            margin-bottom: 30px;
-            backdrop-filter: blur(10px);
-        }
-        .btn {
-            background: rgba(255,255,255,0.2);
-            color: white;
-            padding: 10px 20px;
-            border: none;
-            border-radius: 8px;
-            cursor: pointer;
-            margin: 5px;
-            text-decoration: none;
-            display: inline-block;
-            transition: all 0.3s ease;
-        }
-        .btn:hover {
-            background: rgba(255,255,255,0.3);
-            transform: translateY(-2px);
-        }
-    </style>
-</head>
-<body>
-    <div class="header">
-        <h1>📸 macOS Thumbnail Preview Gallery</h1>
-        <p>Screen and window thumbnails generated with node-mac-recorder</p>
-    </div>
-    
-    <div class="stats">
-        <strong>${previewFiles.length}</strong> Thumbnails Generated<br>
-        <small>Created at ${new Date().toLocaleString()}</small>
-    </div>
-    
-    <div style="text-align: center; margin-bottom: 20px;">
-        ${previewFiles
-					.map(
-						(file) =>
-							`<a href="${file}" class="btn" target="_blank">${file
-								.replace("-preview.html", "")
-								.replace(/-/g, " ")}</a>`
-					)
-					.join("")}
-    </div>
-    
-    <div class="gallery">
-        ${previewFiles
-					.map(
-						(file) => `
-            <div class="preview-card">
-                <div class="card-header">
-                    <h3 class="card-title">${file
-											.replace("-preview.html", "")
-											.replace(/-/g, " ")
-											.toUpperCase()}</h3>
-                    <p class="card-subtitle">${file}</p>
-                </div>
-                <iframe src="${file}"></iframe>
-            </div>
-        `
-					)
-					.join("")}
-    </div>
-    
-    <div style="text-align: center; margin-top: 40px; opacity: 0.8;">
-        <p>🚀 Generated with <strong>node-mac-recorder v1.1.0</strong></p>
-    </div>
-</body>
-</html>`;
-
-			fs.writeFileSync("preview-gallery.html", galleryContent);
-			console.log(`✅ Gallery created: preview-gallery.html`);
-		}
-
-		console.log("\n🎉 Preview Test Completed!");
-		console.log("\n📁 Generated Files:");
-		previewFiles.forEach((file) => console.log(`  - ${file}`));
-		console.log("  - preview-gallery.html (main gallery)");
-
-		console.log("\n🌐 View Results:");
-		console.log("  open preview-gallery.html");
-		console.log("\n💡 Individual files can be opened directly in browser!");
-	} catch (error) {
-		console.error("❌ Preview test failed:", error.message);
-		console.error(error.stack);
-	}
-}
-
-// Run preview test
-testPreviews();