node-mac-recorder 2.16.29 → 2.16.31

package/.claude/settings.local.json

@@ -1,9 +1,7 @@
 {
   "permissions": {
     "allow": [
-      "Bash(FORCE_AVFOUNDATION=1 node test-sequential.js)",
-      "Bash(grep:*)",
-      "Bash(FORCE_AVFOUNDATION=1 node -e \"\nconsole.log(''🧪 Testing macOS 14/13 coordinate scaling fix...'');\nconst MacRecorder = require(''./index.js'');\nconst recorder = new MacRecorder();\n\nrecorder.startRecording(''/tmp/coordinate-fix-test.mov'')\n  .then(success => {\n    console.log(''Start result:'', success ? ''✅ SUCCESS'' : ''❌ FAILED'');\n    if (success) {\n      setTimeout(() => {\n        recorder.stopRecording().then(() => {\n          console.log(''✅ Recording stopped'');\n          const fs = require(''fs'');\n          if (fs.existsSync(''/tmp/coordinate-fix-test.mov'')) {\n            const size = Math.round(fs.statSync(''/tmp/coordinate-fix-test.mov'').size/1024);\n            console.log(''📹 File size:'', size + ''KB'');\n            if (size > 100) {\n              console.log(''🎉 macOS 14/13 coordinate fix test SUCCESS!'');\n            } else {\n              console.log(''⚠️ File too small, may have issues'');\n            }\n          } else {\n            console.log(''❌ No output file created'');\n          }\n        });\n      }, 3000); // 3 seconds recording\n    }\n  })\n  .catch(console.error);\n\")"
+      "Bash(node:*)"
     ],
     "deny": [],
     "ask": []

package/cursor-dpr-test.js

@@ -0,0 +1,73 @@
+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

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

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -65,14 +65,25 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         CGFloat scaleY = physicalSize.height / logicalSize.height;
         CGFloat scaleFactor = MAX(scaleX, scaleY); // Use max to handle non-uniform scaling
         
-        // CRITICAL FIX: Use actual captured image dimensions, not logical size
-        // CGDisplayCreateImage may return higher resolution on Retina displays
+        // CRITICAL FIX: Use actual captured image dimensions for pixel buffer
+        // CGDisplayCreateImage returns physical pixels on Retina displays
         CGImageRef testImage = CGDisplayCreateImage(displayID);
         CGSize actualImageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
         CGImageRelease(testImage);
         
-        // CRITICAL FIX: Use logical size for consistency, actual image size only for validation
-        CGSize recordingSize = captureRect.size.width > 0 ? captureRect.size : logicalSize;
+        // CRITICAL FIX: Use actual image dimensions to match what CGDisplayCreateImage returns
+        // This prevents the "1/4 recording area" bug on Retina displays
+        CGSize recordingSize;
+        if (!CGRectIsEmpty(captureRect)) {
+            // Scale capture rect to match actual image dimensions
+            recordingSize = CGSizeMake(
+                captureRect.size.width * (actualImageSize.width / logicalSize.width),
+                captureRect.size.height * (actualImageSize.height / logicalSize.height)
+            );
+        } else {
+            // Full screen: use actual image size
+            recordingSize = actualImageSize;
+        }
         
         NSLog(@"🎯 CRITICAL: Logical %.0fx%.0f → Actual image %.0fx%.0f", 
               logicalSize.width, logicalSize.height, actualImageSize.width, actualImageSize.height);
@@ -88,7 +99,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             NSLog(@"🔍 Scale factor: %.1fx → Standard display", scaleFactor);
         }
         
-        NSLog(@"🎯 Recording size: %.0fx%.0f (using logical dimensions for AVFoundation)", recordingSize.width, recordingSize.height);
+        NSLog(@"🎯 Recording size: %.0fx%.0f (using actual physical dimensions for Retina fix)", recordingSize.width, recordingSize.height);
         
         // Video settings with macOS compatibility
         NSString *codecKey;
@@ -154,25 +165,34 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         // Store recording parameters with scaling correction
         g_avDisplayID = displayID;
         
-        // CRITICAL FIX: Use coordinates as-is from JS layer (already display-relative)
+        // CRITICAL FIX: Scale capture coordinates to match physical pixels
         if (!CGRectIsEmpty(captureRect)) {
-            // Use coordinates directly - JS layer already converted global to display-relative
-            g_avCaptureRect = captureRect;
+            // Scale coordinates from logical to physical (for CGDisplayCreateImage)
+            CGFloat scaleFactorX = actualImageSize.width / logicalSize.width;
+            CGFloat scaleFactorY = actualImageSize.height / logicalSize.height;
+            
+            g_avCaptureRect = CGRectMake(
+                captureRect.origin.x * scaleFactorX,
+                captureRect.origin.y * scaleFactorY,
+                captureRect.size.width * scaleFactorX,
+                captureRect.size.height * scaleFactorY
+            );
             
-            NSLog(@"🔲 macOS 14/13 FIXED: Display-relative capture area: %.0f,%.0f %.0fx%.0f", 
-                  captureRect.origin.x, captureRect.origin.y, captureRect.size.width, captureRect.size.height);
+            NSLog(@"🔲 RETINA FIX: Logical (%.0f,%.0f %.0fx%.0f) → Physical (%.0f,%.0f %.0fx%.0f)", 
+                  captureRect.origin.x, captureRect.origin.y, captureRect.size.width, captureRect.size.height,
+                  g_avCaptureRect.origin.x, g_avCaptureRect.origin.y, g_avCaptureRect.size.width, g_avCaptureRect.size.height);
             
-            // Validate coordinates are within logical display bounds
-            if (captureRect.origin.x >= 0 && captureRect.origin.y >= 0 && 
-                captureRect.origin.x + captureRect.size.width <= logicalSize.width &&
-                captureRect.origin.y + captureRect.size.height <= logicalSize.height) {
-                NSLog(@"✅ Coordinates validated within logical display bounds %.0fx%.0f", logicalSize.width, logicalSize.height);
+            // Validate coordinates are within physical display bounds
+            if (g_avCaptureRect.origin.x >= 0 && g_avCaptureRect.origin.y >= 0 && 
+                g_avCaptureRect.origin.x + g_avCaptureRect.size.width <= actualImageSize.width &&
+                g_avCaptureRect.origin.y + g_avCaptureRect.size.height <= actualImageSize.height) {
+                NSLog(@"✅ Coordinates validated within physical display bounds %.0fx%.0f", actualImageSize.width, actualImageSize.height);
             } else {
-                NSLog(@"⚠️ Coordinates may be outside logical display bounds - clipping may occur");
+                NSLog(@"⚠️ Coordinates may be outside physical display bounds - clipping may occur");
             }
         } else {
             g_avCaptureRect = CGRectZero; // Full screen
-            NSLog(@"🖥️ Full screen capture using logical dimensions %.0fx%.0f", logicalSize.width, logicalSize.height);
+            NSLog(@"🖥️ Full screen capture using physical dimensions %.0fx%.0f", actualImageSize.width, actualImageSize.height);
         }
         
         g_avFrameNumber = 0;

package/src/cursor_tracker.mm

@@ -20,6 +20,7 @@ static bool g_isFirstWrite = true;
 // Forward declaration
 void cursorTimerCallback();
 void writeToFile(NSDictionary *cursorData);
+NSDictionary* getDisplayScalingInfo(CGPoint globalPoint);
 
 // Timer helper class
 @interface CursorTimerTarget : NSObject
@@ -198,7 +199,28 @@ CGEventRef eventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef eve
             return event;
         }
         
-        CGPoint location = CGEventGetLocation(event);
+        CGPoint rawLocation = CGEventGetLocation(event);
+        
+        // Apply DPR scaling correction for Retina displays
+        NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
+        CGPoint location = rawLocation;
+        
+        if (scalingInfo) {
+            CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
+            NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
+            
+            if (scaleFactor > 1.1) {
+                // Convert to logical coordinates
+                CGFloat displayRelativeX = rawLocation.x - displayBounds.origin.x;
+                CGFloat displayRelativeY = rawLocation.y - displayBounds.origin.y;
+                
+                CGFloat logicalRelativeX = displayRelativeX / scaleFactor;
+                CGFloat logicalRelativeY = displayRelativeY / scaleFactor;
+                
+                location.x = displayBounds.origin.x + logicalRelativeX;
+                location.y = displayBounds.origin.y + logicalRelativeY;
+            }
+        }
         NSDate *currentDate = [NSDate date];
         NSTimeInterval timestamp = [currentDate timeIntervalSinceDate:g_trackingStartTime] * 1000; // milliseconds
         NSTimeInterval unixTimeMs = [currentDate timeIntervalSince1970] * 1000; // unix timestamp in milliseconds
@@ -254,13 +276,34 @@ void cursorTimerCallback() {
             return;
         }
         
-        // CGEventGetLocation direkt global koordinat verir - çoklu ekran desteği için daha doğru
+        // Get cursor position with DPR scaling correction
         CGEventRef event = CGEventCreate(NULL);
-        CGPoint location = CGEventGetLocation(event);
+        CGPoint rawLocation = CGEventGetLocation(event);
         if (event) {
             CFRelease(event);
         }
         
+        // Apply DPR scaling correction for Retina displays
+        NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
+        CGPoint location = rawLocation;
+        
+        if (scalingInfo) {
+            CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
+            NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
+            
+            if (scaleFactor > 1.1) {
+                // Convert to logical coordinates
+                CGFloat displayRelativeX = rawLocation.x - displayBounds.origin.x;
+                CGFloat displayRelativeY = rawLocation.y - displayBounds.origin.y;
+                
+                CGFloat logicalRelativeX = displayRelativeX / scaleFactor;
+                CGFloat logicalRelativeY = displayRelativeY / scaleFactor;
+                
+                location.x = displayBounds.origin.x + logicalRelativeX;
+                location.y = displayBounds.origin.y + logicalRelativeY;
+            }
+        }
+        
         NSDate *currentDate = [NSDate date];
         NSTimeInterval timestamp = [currentDate timeIntervalSinceDate:g_trackingStartTime] * 1000; // milliseconds
         NSTimeInterval unixTimeMs = [currentDate timeIntervalSince1970] * 1000; // unix timestamp in milliseconds
@@ -435,19 +478,94 @@ Napi::Value StopCursorTracking(const Napi::CallbackInfo& info) {
     }
 }
 
+// Helper function to get display scaling info for cursor coordinates
+NSDictionary* getDisplayScalingInfo(CGPoint globalPoint) {
+    @try {
+        // Get all displays
+        uint32_t displayCount;
+        CGDirectDisplayID displayIDs[32];
+        CGGetActiveDisplayList(32, displayIDs, &displayCount);
+        
+        // Find which display contains this point
+        for (uint32_t i = 0; i < displayCount; i++) {
+            CGDirectDisplayID displayID = displayIDs[i];
+            CGRect displayBounds = CGDisplayBounds(displayID);
+            
+            // Check if point is within this display
+            if (CGRectContainsPoint(displayBounds, globalPoint)) {
+                // Get display scaling info
+                CGSize logicalSize = displayBounds.size;
+                CGSize physicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
+                
+                CGFloat scaleX = physicalSize.width / logicalSize.width;
+                CGFloat scaleY = physicalSize.height / logicalSize.height;
+                CGFloat scaleFactor = MAX(scaleX, scaleY);
+                
+                return @{
+                    @"displayID": @(displayID),
+                    @"logicalSize": [NSValue valueWithSize:NSMakeSize(logicalSize.width, logicalSize.height)],
+                    @"physicalSize": [NSValue valueWithSize:NSMakeSize(physicalSize.width, physicalSize.height)],
+                    @"scaleFactor": @(scaleFactor),
+                    @"displayBounds": [NSValue valueWithRect:NSMakeRect(displayBounds.origin.x, displayBounds.origin.y, displayBounds.size.width, displayBounds.size.height)]
+                };
+            }
+        }
+        
+        // Fallback to main display
+        CGDirectDisplayID mainDisplay = CGMainDisplayID();
+        CGRect displayBounds = CGDisplayBounds(mainDisplay);
+        CGSize logicalSize = displayBounds.size;
+        CGSize physicalSize = CGSizeMake(CGDisplayPixelsWide(mainDisplay), CGDisplayPixelsHigh(mainDisplay));
+        
+        return @{
+            @"displayID": @(mainDisplay),
+            @"logicalSize": [NSValue valueWithSize:NSMakeSize(logicalSize.width, logicalSize.height)],
+            @"physicalSize": [NSValue valueWithSize:NSMakeSize(physicalSize.width, physicalSize.height)],
+            @"scaleFactor": @(MAX(physicalSize.width / logicalSize.width, physicalSize.height / logicalSize.height)),
+            @"displayBounds": [NSValue valueWithRect:NSMakeRect(displayBounds.origin.x, displayBounds.origin.y, displayBounds.size.width, displayBounds.size.height)]
+        };
+    } @catch (NSException *exception) {
+        return nil;
+    }
+}
+
 // NAPI Function: Get Current Cursor Position
 Napi::Value GetCursorPosition(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
     @try {
-        // NSEvent mouseLocation zaten global koordinatlarda (all displays combined)
-        // CGEventGetLocation kullanarak direkt global koordinat al - daha doğru
+        // Get raw cursor position (may be scaled on Retina displays)
         CGEventRef event = CGEventCreate(NULL);
-        CGPoint location = CGEventGetLocation(event);
+        CGPoint rawLocation = CGEventGetLocation(event);
         if (event) {
             CFRelease(event);
         }
         
+        // Get display scaling information
+        NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
+        CGPoint logicalLocation = rawLocation;
+        
+        if (scalingInfo) {
+            CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
+            NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
+            
+            // CRITICAL FIX: Convert physical coordinates to logical coordinates
+            // CGEventGetLocation returns physical coordinates on Retina displays
+            if (scaleFactor > 1.1) {
+                // Convert to display-relative, then scale down to logical, then back to global logical
+                CGFloat displayRelativeX = rawLocation.x - displayBounds.origin.x;
+                CGFloat displayRelativeY = rawLocation.y - displayBounds.origin.y;
+                
+                // Scale down to logical coordinates
+                CGFloat logicalRelativeX = displayRelativeX / scaleFactor;
+                CGFloat logicalRelativeY = displayRelativeY / scaleFactor;
+                
+                // Convert back to global logical coordinates
+                logicalLocation.x = displayBounds.origin.x + logicalRelativeX;
+                logicalLocation.y = displayBounds.origin.y + logicalRelativeY;
+            }
+        }
+        
         NSString *cursorType = getCursorType();
         
         // Mouse button state'ini kontrol et
@@ -479,11 +597,19 @@ Napi::Value GetCursorPosition(const Napi::CallbackInfo& info) {
         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("x", Napi::Number::New(env, (int)logicalLocation.x));
+        result.Set("y", Napi::Number::New(env, (int)logicalLocation.y));
         result.Set("cursorType", Napi::String::New(env, [cursorType UTF8String]));
         result.Set("eventType", Napi::String::New(env, [eventType UTF8String]));
         
+        // Add scaling debug info
+        if (scalingInfo) {
+            CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
+            result.Set("scaleFactor", Napi::Number::New(env, scaleFactor));
+            result.Set("rawX", Napi::Number::New(env, (int)rawLocation.x));
+            result.Set("rawY", Napi::Number::New(env, (int)rawLocation.y));
+        }
+        
         return result;
         
     } @catch (NSException *exception) {