node-mac-recorder 2.17.20 → 2.17.21

package/.claude/settings.local.json

@@ -7,7 +7,9 @@
       "Bash(git checkout:*)",
       "WebSearch",
       "WebFetch(domain:stackoverflow.com)",
-      "Bash(timeout:*)"
+      "Bash(timeout:*)",
+      "Bash(grep:*)",
+      "Bash(./test-cleanup.sh:*)"
     ],
     "deny": [],
     "ask": []

package/index.js

@@ -647,11 +647,9 @@ class MacRecorder extends EventEmitter {
 	 */
 	async startCursorCapture(intervalOrFilepath = 100, 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;
@@ -665,207 +663,28 @@ class MacRecorder extends EventEmitter {
 			throw new Error("Cursor capture is already running");
 		}
 
-		// Koordinat sistemi belirle: window-relative, display-relative veya global
-		if (options.windowRelative && options.windowInfo) {
-			const windowInfo = options.windowInfo;
-			const targetDisplay = windowInfo.targetDisplay || this.recordingDisplayInfo || null;
-			const captureArea = windowInfo.captureArea || null;
-			const hasNumber = (value) => typeof value === "number" && Number.isFinite(value);
-
-			let globalX = hasNumber(windowInfo.x) ? windowInfo.x : null;
-			let globalY = hasNumber(windowInfo.y) ? windowInfo.y : null;
-
-			if (captureArea && targetDisplay) {
-				if (!hasNumber(globalX) && hasNumber(captureArea.x) && hasNumber(targetDisplay.x)) {
-					globalX = targetDisplay.x + captureArea.x;
-				}
-				if (!hasNumber(globalY) && hasNumber(captureArea.y) && hasNumber(targetDisplay.y)) {
-					globalY = targetDisplay.y + captureArea.y;
-				}
-			}
-
-			if (!hasNumber(globalX)) {
-				if (captureArea && hasNumber(captureArea.x) && targetDisplay && hasNumber(targetDisplay.x)) {
-					globalX = targetDisplay.x + captureArea.x;
-				} else {
-					globalX = hasNumber(captureArea?.x) ? captureArea.x : 0;
-				}
-			}
-
-			if (!hasNumber(globalY)) {
-				if (captureArea && hasNumber(captureArea.y) && targetDisplay && hasNumber(targetDisplay.y)) {
-					globalY = targetDisplay.y + captureArea.y;
-				} else {
-					globalY = hasNumber(captureArea?.y) ? captureArea.y : 0;
-				}
-			}
-
-			const displayOffsetX = captureArea && hasNumber(captureArea.x)
-				? captureArea.x
-				: (targetDisplay && hasNumber(globalX) && hasNumber(targetDisplay.x)
-					? globalX - targetDisplay.x
-					: globalX);
-			const displayOffsetY = captureArea && hasNumber(captureArea.y)
-				? captureArea.y
-				: (targetDisplay && hasNumber(globalY) && hasNumber(targetDisplay.y)
-					? globalY - targetDisplay.y
-					: globalY);
-
-			this.cursorDisplayInfo = {
-				displayId:
-					windowInfo.displayId ??
-					targetDisplay?.displayId ??
-					targetDisplay?.id ??
-					null,
-				x: globalX,
-				y: globalY,
-				width: windowInfo.width,
-				height: windowInfo.height,
-				windowRelative: true,
-				windowInfo: {
-					...windowInfo,
-					globalX,
-					globalY,
-					displayOffsetX,
-					displayOffsetY
-				},
-				targetDisplay,
-				captureArea
-			};
-		} else if (options.displayRelative && options.displayInfo) {
-			// Display recording: Use display-relative coordinates
-			this.cursorDisplayInfo = {
-				displayId: options.displayInfo.displayId,
-				x: options.displayInfo.x,
-				y: options.displayInfo.y,
-				width: options.displayInfo.width,
-				height: options.displayInfo.height,
-				displayRelative: true
-			};
-		} else if (this.recordingDisplayInfo) {
-			// Fallback: Use recording display info if available
-			this.cursorDisplayInfo = this.recordingDisplayInfo;
-		} 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]),
-					};
-				}
-			} 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;
-				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;
-
-						// Transform coordinates based on recording type
-						let x = position.x;
-						let y = position.y;
-						let coordinateSystem = "global";
-
-						if (this.cursorDisplayInfo) {
-							if (this.cursorDisplayInfo.windowRelative) {
-								// Window recording: Use direct global-to-window transformation
-								// This works correctly for both primary and secondary displays
-								x = position.x - this.cursorDisplayInfo.x;
-								y = position.y - this.cursorDisplayInfo.y;
-
-								coordinateSystem = "window-relative";
-
-								// Window bounds check - skip if cursor is outside window
-								if (x < 0 || y < 0 || x >= this.cursorDisplayInfo.width || y >= this.cursorDisplayInfo.height) {
-									return; // Skip frame - cursor outside window
-								}
-							} else if (this.cursorDisplayInfo.displayRelative) {
-								// Display recording: Transform global → display-relative coordinates
-								x = position.x - this.cursorDisplayInfo.x;
-								y = position.y - this.cursorDisplayInfo.y;
-								coordinateSystem = "display-relative";
-
-								// Display bounds check - skip if cursor is outside display
-								if (x < 0 || y < 0 || x >= this.cursorDisplayInfo.width || y >= this.cursorDisplayInfo.height) {
-									return; // Skip frame - cursor outside display
-								}
-							} else {
-								// Legacy fallback: Use global coordinates with basic offset
-								x = position.x - this.cursorDisplayInfo.x;
-								y = position.y - this.cursorDisplayInfo.y;
-								coordinateSystem = "display-relative";
-							}
-						}
-
-						const cursorData = {
-							x: x,
-							y: y,
-							timestamp: timestamp,
-							unixTimeMs: Date.now(),
-							cursorType: position.cursorType,
-							type: position.eventType || "move",
-							coordinateSystem: coordinateSystem,
-							// Include recording context for window-relative coordinates
-							...(this.cursorDisplayInfo?.windowRelative && {
-								windowInfo: {
-									width: this.cursorDisplayInfo.width,
-									height: this.cursorDisplayInfo.height,
-									displayId: this.cursorDisplayInfo.displayId
-								}
-							}),
-							// Include display context for display-relative coordinates
-							...(this.cursorDisplayInfo?.displayRelative && {
-								displayInfo: {
-									displayId: this.cursorDisplayInfo.displayId,
-									width: this.cursorDisplayInfo.width,
-									height: this.cursorDisplayInfo.height
-								}
-							})
-						};
+				// Native cursor tracking kullan - hem screen hem window için aynı yöntem
+				const success = nativeBinding.startCursorTracking(filepath);
 
-						// 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);
-							}
+				if (success) {
+					this.cursorCaptureFile = filepath;
+					this.cursorCaptureStartTime = Date.now();
+					this.cursorCaptureInterval = true; // Mark as active
 
-							// Son pozisyonu sakla
-							this.lastCapturedData = { ...cursorData };
-						}
-					} catch (error) {
-						console.error("Cursor capture error:", error);
-					}
-				}, interval); // Configurable FPS
+					this.emit("cursorCaptureStarted", {
+						filepath: filepath,
+						timestamp: Date.now()
+					});
 
-				this.emit("cursorCaptureStarted", filepath);
-				resolve(true);
+					resolve({
+						filepath: filepath,
+						started: true
+					});
+				} else {
+					reject(new Error("Failed to start native cursor tracking"));
+				}
 			} catch (error) {
 				reject(error);
 			}

package/package.json

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

package/publish.sh

@@ -26,6 +26,24 @@ if ! git rev-parse --git-dir > /dev/null 2>&1; then
     exit 1
 fi
 
+# Clean up test files and video files before publishing
+echo "🧹 Cleaning up test files and video files..."
+
+# Remove video files (MP4, MOV, AVI, etc.)
+find . -maxdepth 1 -type f \( -name "*.mp4" -o -name "*.mov" -o -name "*.avi" -o -name "*.mkv" -o -name "*.webm" \) -delete
+
+# Remove test output directories
+rm -rf test-output debug-output
+
+# Remove test files and temporary files
+find . -maxdepth 1 -type f \( -name "*test*.json" -o -name "*debug*.json" -o -name "*cursor*.json" -o -name "temp-*" -o -name "*-temp.*" -o -name "*.tmp" \) -delete
+
+# Remove test JavaScript files that shouldn't be published
+find . -maxdepth 1 -type f -name "*test*.js" ! -name "test.js" -delete
+find . -maxdepth 1 -type f -name "*debug*.js" -delete
+
+echo "✅ Cleanup completed"
+
 # Check if there are uncommitted changes
 if ! git diff --quiet || ! git diff --cached --quiet; then
     echo "📁 Adding all changes to git..."

package/src/cursor_tracker.mm

@@ -13,7 +13,7 @@ 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 dispatch_source_t g_cursorTimer = nil;
 static int g_debugCallbackCount = 0;
 static NSFileHandle *g_fileHandle = nil;
 static bool g_isFirstWrite = true;
@@ -623,8 +623,16 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
 void cursorTimerCallback() {
     @autoreleasepool {
         g_debugCallbackCount++; // Timer callback çağrıldığını say
-        
+
+        static int callCount = 0;
+        callCount++;
+        if (callCount <= 3) {
+            NSLog(@"🔄 Timer callback #%d called", callCount);
+        }
+
         if (!g_isCursorTracking || !g_trackingStartTime || !g_fileHandle) {
+            NSLog(@"❌ Timer callback stopped - tracking:%d, startTime:%@, fileHandle:%@",
+                  g_isCursorTracking, g_trackingStartTime ? @"OK" : @"nil", g_fileHandle ? @"OK" : @"nil");
             return;
         }
         
@@ -673,16 +681,14 @@ void cursorTimerCallback() {
 void cleanupCursorTracking() {
     g_isCursorTracking = false;
     
-    // Timer temizle
+    // GCD Timer temizle
     if (g_cursorTimer) {
-        [g_cursorTimer invalidate];
+        dispatch_source_cancel(g_cursorTimer);
+        dispatch_release(g_cursorTimer);
         g_cursorTimer = nil;
     }
     
-    if (g_timerTarget) {
-        [g_timerTarget autorelease];
-        g_timerTarget = nil;
-    }
+    // Timer target artık kullanılmıyor (GCD kullanıyoruz)
     
     // Dosyayı önce kapat (en önemli işlem)
     if (g_fileHandle) {
@@ -788,19 +794,30 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
             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];
-        
+        // GCD Timer kullan (Node.js ile uyumlu)
+        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+        g_cursorTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
+
+        if (g_cursorTimer) {
+            dispatch_source_set_timer(g_cursorTimer,
+                                     dispatch_time(DISPATCH_TIME_NOW, 50 * NSEC_PER_MSEC), // Start after 50ms
+                                     50 * NSEC_PER_MSEC, // Repeat every 50ms (20 FPS)
+                                     10 * NSEC_PER_MSEC); // Leeway of 10ms
+
+            dispatch_source_set_event_handler(g_cursorTimer, ^{
+                cursorTimerCallback();
+            });
+
+            dispatch_resume(g_cursorTimer);
+        }
+
         g_isCursorTracking = true;
+
+        NSLog(@"🎯 Native cursor tracking started with timer and event tap");
+        NSLog(@"🎯 File handle: %@", g_fileHandle ? @"OK" : @"FAILED");
+        NSLog(@"🎯 Timer: %@", g_cursorTimer ? @"OK" : @"FAILED");
+        NSLog(@"🎯 Event tap: %@", g_eventTap ? @"OK" : @"FAILED");
+
         return Napi::Boolean::New(env, true);
         
     } @catch (NSException *exception) {

package/cursor-debug-test.js

@@ -1,60 +0,0 @@
-const MacRecorder = require('./index.js');
-
-console.log('🔍 Debugging cursor coordinate scaling issue...\n');
-
-const recorder = new MacRecorder();
-
-async function testCursorScaling() {
-    console.log('Getting display info...');
-    const displays = await recorder.getDisplays();
-    
-    displays.forEach((display, index) => {
-        console.log(`Display ${index}:`);
-        console.log(`  Resolution: ${display.resolution}`);
-        console.log(`  Position: (${display.x}, ${display.y})`);
-        console.log(`  Primary: ${display.isPrimary}`);
-        console.log(`  ID: ${display.id}`);
-    });
-    
-    console.log('\n🎯 Please move your mouse to different corners and press Enter...');
-    console.log('This will help us understand the coordinate mapping issue.\n');
-    
-    const readline = require('readline');
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    
-    let testCount = 0;
-    const testPositions = [
-        'Top-Left corner of the display',
-        'Top-Right corner of the display', 
-        'Bottom-Left corner of the display',
-        'Bottom-Right corner of the display',
-        'Center of the display'
-    ];
-    
-    function nextTest() {
-        if (testCount >= testPositions.length) {
-            console.log('\n✅ Test completed!');
-            rl.close();
-            process.exit(0);
-            return;
-        }
-        
-        console.log(`\n📍 Test ${testCount + 1}: Move mouse to ${testPositions[testCount]} and press Enter:`);
-        rl.question('', () => {
-            const position = recorder.getCursorPosition();
-            console.log(`   Raw cursor position: (${position.rawX || 'N/A'}, ${position.rawY || 'N/A'})`);
-            console.log(`   Logical cursor position: (${position.x}, ${position.y})`);
-            console.log(`   Scale factor: ${position.scaleFactor || 'N/A'}x`);
-            
-            testCount++;
-            nextTest();
-        });
-    }
-    
-    nextTest();
-}
-
-testCursorScaling().catch(console.error);

package/cursor-dpr-test.js

@@ -1,73 +0,0 @@
-const MacRecorder = require('./index.js');
-
-console.log('🧪 Testing cursor DPR scaling fixes...\n');
-
-const recorder = new MacRecorder();
-
-// Test basic cursor position
-console.log('1. Testing basic cursor position:');
-try {
-    const position = recorder.getCursorPosition();
-    console.log(`   Position: (${position.x}, ${position.y})`);
-    
-    // If we have scaling debug info, show it
-    if (position.scaleFactor) {
-        console.log(`   Scale factor: ${position.scaleFactor}x`);
-        console.log(`   Raw position: (${position.rawX}, ${position.rawY})`);
-        console.log(`   Logical position: (${position.x}, ${position.y})`);
-    }
-} catch (error) {
-    console.error('   Error:', error.message);
-}
-
-console.log('\n2. Testing display information:');
-recorder.getDisplays().then(displays => {
-    displays.forEach((display, index) => {
-        console.log(`   Display ${index}: ${display.resolution} at (${display.x}, ${display.y})`);
-        console.log(`     Primary: ${display.isPrimary}, ID: ${display.id}`);
-    });
-    
-    console.log('\n3. Testing cursor capture with DPR fix:');
-    const outputFile = 'cursor-dpr-test.json';
-    
-    recorder.startCursorCapture(outputFile, 50).then(() => {
-        console.log(`   ✅ Cursor capture started, saving to ${outputFile}`);
-        console.log('   Move your mouse around for 5 seconds...');
-        
-        setTimeout(() => {
-            recorder.stopCursorCapture().then(() => {
-                console.log('   ✅ Cursor capture stopped');
-                
-                // Read and analyze the captured data
-                const fs = require('fs');
-                try {
-                    const data = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
-                    if (data.length > 0) {
-                        const first = data[0];
-                        const last = data[data.length - 1];
-                        
-                        console.log(`   📊 Captured ${data.length} cursor events`);
-                        console.log(`   📍 First: (${first.x}, ${first.y}) ${first.coordinateSystem || 'unknown'}`);
-                        console.log(`   📍 Last: (${last.x}, ${last.y}) ${last.coordinateSystem || 'unknown'}`);
-                        
-                        // Check coordinate system
-                        const hasCoordinateSystem = data.some(d => d.coordinateSystem);
-                        console.log(`   🎯 Coordinate system info: ${hasCoordinateSystem ? 'Present' : 'Missing'}`);
-                    } else {
-                        console.log('   ⚠️ No cursor events captured');
-                    }
-                } catch (readError) {
-                    console.error('   ❌ Error reading capture file:', readError.message);
-                }
-                
-                process.exit(0);
-            });
-        }, 5000);
-    }).catch(error => {
-        console.error('   ❌ Cursor capture failed:', error.message);
-        process.exit(1);
-    });
-}).catch(error => {
-    console.error('   Error getting displays:', error.message);
-    process.exit(1);
-});

package/cursor-dpr-test.json

@@ -1 +0,0 @@
-[]

package/cursor-macbook-test.js

@@ -1,63 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function testMacBookCursor() {
-    console.log('🖥️  Testing cursor on MacBook internal display...\n');
-    
-    const recorder = new MacRecorder();
-    
-    // Get displays
-    const displays = await recorder.getDisplays();
-    console.log('📺 Available displays:');
-    displays.forEach((display, index) => {
-        console.log(`   Display ${index}: ${display.resolution} at (${display.x}, ${display.y}) - Primary: ${display.isPrimary}`);
-    });
-    
-    console.log('\n🎯 Move your mouse to the PRIMARY MacBook display and press any key...');
-    console.log('(Make sure cursor is on the built-in MacBook screen, not external monitor)\n');
-    
-    // Wait for keypress
-    await new Promise((resolve) => {
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.once('data', () => {
-            process.stdin.setRawMode(false);
-            resolve();
-        });
-    });
-    
-    console.log('🔍 Testing cursor position on MacBook display:');
-    for (let i = 0; i < 3; i++) {
-        const position = recorder.getCursorPosition();
-        console.log(`\n   Test ${i+1}:`);
-        console.log(`     Cursor: (${position.x}, ${position.y})`);
-        console.log(`     Cursor type: ${position.cursorType}`);
-        
-        // Check which display cursor is on
-        const primaryDisplay = displays.find(d => d.isPrimary);
-        if (primaryDisplay) {
-            const isOnPrimary = position.x >= primaryDisplay.x && 
-                               position.x < primaryDisplay.x + parseInt(primaryDisplay.resolution.split('x')[0]) &&
-                               position.y >= primaryDisplay.y && 
-                               position.y < primaryDisplay.y + parseInt(primaryDisplay.resolution.split('x')[1]);
-            
-            console.log(`     On primary display: ${isOnPrimary ? '✅ YES' : '❌ NO'}`);
-        }
-        
-        if (position.scaleFactor) {
-            console.log(`     Scale factor: ${position.scaleFactor}x`);
-            if (position.displayInfo) {
-                console.log(`     Display logical: ${position.displayInfo.logicalWidth}x${position.displayInfo.logicalHeight}`);
-                console.log(`     Display physical: ${position.displayInfo.physicalWidth}x${position.displayInfo.physicalHeight}`);
-                console.log(`     Raw cursor: (${position.rawX}, ${position.rawY})`);
-            }
-        } else {
-            console.log(`     ⚠️ No scaling info detected`);
-        }
-        
-        await new Promise(resolve => setTimeout(resolve, 1000));
-    }
-    
-    process.exit(0);
-}
-
-testMacBookCursor().catch(console.error);

package/cursor-permission-test.js

@@ -1,46 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function testCursorPermissions() {
-    console.log('🔒 Testing cursor tracking permissions...\n');
-    
-    const recorder = new MacRecorder();
-    
-    // Check permissions first
-    console.log('1. Checking permissions:');
-    const permissions = await recorder.checkPermissions();
-    console.log('   Screen Recording:', permissions.screenRecording ? '✅' : '❌');
-    console.log('   Accessibility:', permissions.accessibility ? '✅' : '❌');
-    console.log('   Microphone:', permissions.microphone ? '✅' : '❌');
-    
-    if (permissions.error) {
-        console.log('   Error:', permissions.error);
-    }
-    
-    console.log('\n2. Testing direct cursor position (no capture):');
-    for (let i = 0; i < 5; i++) {
-        try {
-            const position = recorder.getCursorPosition();
-            console.log(`   Position ${i+1}: (${position.x}, ${position.y}) - ${position.cursorType}`);
-            
-            if (position.scaleFactor) {
-                console.log(`     Scale: ${position.scaleFactor}x, Display: (${position.displayInfo?.displayX}, ${position.displayInfo?.displayY})`);
-                console.log(`     Logical: ${position.displayInfo?.logicalWidth}x${position.displayInfo?.logicalHeight}`);
-                console.log(`     Physical: ${position.displayInfo?.physicalWidth}x${position.displayInfo?.physicalHeight}`);
-            }
-            
-            await new Promise(resolve => setTimeout(resolve, 500));
-        } catch (error) {
-            console.error(`   Error getting position ${i+1}:`, error.message);
-        }
-    }
-    
-    console.log('\n3. Testing cursor capture status:');
-    const status = recorder.getCursorCaptureStatus();
-    console.log('   Is Capturing:', status.isCapturing);
-    console.log('   Output File:', status.outputFile);
-    console.log('   Display Info:', status.displayInfo);
-    
-    process.exit(0);
-}
-
-testCursorPermissions().catch(console.error);

package/cursor-scaling-debug.js

@@ -1,53 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function debugCursorScaling() {
-    console.log('🔍 Debugging cursor scaling detection...\n');
-    
-    const recorder = new MacRecorder();
-    
-    // Get all displays
-    const displays = await recorder.getDisplays();
-    console.log('📺 Available displays:');
-    displays.forEach((display, index) => {
-        console.log(`   Display ${index}: ID=${display.id}, ${display.resolution} at (${display.x}, ${display.y}), Primary: ${display.isPrimary}`);
-    });
-    
-    console.log('\n🎯 Current cursor position analysis:');
-    const position = recorder.getCursorPosition();
-    
-    console.log(`   Logical position: (${position.x}, ${position.y})`);
-    console.log(`   Cursor type: ${position.cursorType}`);
-    console.log(`   Event type: ${position.eventType}`);
-    
-    if (position.scaleFactor) {
-        console.log(`   Scale factor detected: ${position.scaleFactor}x`);
-        if (position.displayInfo) {
-            const info = position.displayInfo;
-            console.log(`   Display bounds: (${info.displayX}, ${info.displayY})`);
-            console.log(`   Logical size: ${info.logicalWidth}x${info.logicalHeight}`);
-            console.log(`   Physical size: ${info.physicalWidth}x${info.physicalHeight}`);
-            console.log(`   Raw position: (${position.rawX}, ${position.rawY})`);
-        }
-    } else {
-        console.log(`   ❌ No scale factor detected`);
-        console.log(`   This could mean:`);
-        console.log(`     - getDisplayScalingInfo() didn't find the correct display`);
-        console.log(`     - Display detection logic needs debugging`);
-    }
-    
-    // Find which display the cursor is on
-    console.log('\n🔍 Manual display detection:');
-    displays.forEach((display, index) => {
-        const inX = position.x >= display.x && position.x < display.x + parseInt(display.resolution.split('x')[0]);
-        const inY = position.y >= display.y && position.y < display.y + parseInt(display.resolution.split('x')[1]);
-        const isInside = inX && inY;
-        
-        console.log(`   Display ${index} (${display.resolution}): ${isInside ? '✅ CURSOR IS HERE' : '❌'}`);
-        console.log(`     Bounds: X(${display.x} - ${display.x + parseInt(display.resolution.split('x')[0])}), Y(${display.y} - ${display.y + parseInt(display.resolution.split('x')[1])})`);
-        console.log(`     Cursor: X(${position.x}), Y(${position.y})`);
-    });
-    
-    process.exit(0);
-}
-
-debugCursorScaling().catch(console.error);