node-mac-recorder 2.20.9 → 2.20.11

package/.claude/settings.local.json

@@ -3,7 +3,8 @@
     "allow": [
       "Bash(node-gyp:*)",
       "Bash(node:*)",
-      "Bash(timeout:*)"
+      "Bash(timeout:*)",
+      "Bash(open:*)"
     ],
     "deny": [],
     "ask": []

package/index.js

@@ -217,7 +217,7 @@ class MacRecorder extends EventEmitter {
 							adjustedX = targetWindow.x - display.x;
 							adjustedY = targetWindow.y - display.y;
 							
-							console.log(`🔧 macOS 14/13 coordinate fix: Global (${targetWindow.x},${targetWindow.y}) -> Display-relative (${adjustedX},${adjustedY})`);
+							// console.log(`🔧 macOS 14/13 coordinate fix: Global (${targetWindow.x},${targetWindow.y}) -> Display-relative (${adjustedX},${adjustedY})`);
 							break;
 						}
 					}
@@ -271,9 +271,9 @@ class MacRecorder extends EventEmitter {
 						height: targetWindow.height,
 					};
 
-					console.log(
-						`Window ${targetWindow.appName}: display=${targetDisplayId}, coords=${targetWindow.x},${targetWindow.y} -> ${adjustedX},${adjustedY}`
-					);
+					// console.log(
+					//	`Window ${targetWindow.appName}: display=${targetDisplayId}, coords=${targetWindow.x},${targetWindow.y} -> ${adjustedX},${adjustedY}`
+					// );
 				}
 			} catch (error) {
 				console.warn(
@@ -357,7 +357,7 @@ class MacRecorder extends EventEmitter {
 						recordingOptions
 					);
 				} catch (error) {
-					console.log('Native recording failed, trying alternative method');
+					// console.log('Native recording failed, trying alternative method');
 					success = false;
 				}
 
@@ -466,7 +466,7 @@ class MacRecorder extends EventEmitter {
 				try {
 					success = nativeBinding.stopRecording();
 				} catch (nativeError) {
-					console.log('Native stop failed:', nativeError.message);
+					// console.log('Native stop failed:', nativeError.message);
 					success = true; // Assume success to avoid throwing
 				}
 

package/package.json

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

package/src/cursor_tracker.mm

@@ -525,7 +525,7 @@ static NSString* cursorTypeFromNSCursor(NSCursor *cursor) {
         return @"default";
     }
 
-    // Standard macOS cursors
+    // PRIORITY: Standard macOS cursor pointer equality (most reliable)
     if (cursor == [NSCursor arrowCursor]) {
         return @"default";
     }
@@ -602,23 +602,28 @@ static NSString* cursorTypeFromNSCursor(NSCursor *cursor) {
     NSString *className = NSStringFromClass([cursor class]);
     NSString *description = [cursor description];
 
-    MRLog(@"🔍 Unknown cursor class: %@, description: %@", className ?: @"nil", description ?: @"nil");
+    // Debug: Check for pointer cursor patterns
+    if (className && ([className containsString:@"pointing"] || [className containsString:@"Hand"])) {
+        NSLog(@"🔍 POINTER CLASS: %@", className);
+        return @"pointer";
+    }
+    if (description && ([description containsString:@"pointing"] || [description containsString:@"hand"])) {
+        NSLog(@"🔍 POINTER DESC: %@", description);
+        return @"pointer";
+    }
 
     // Try name-based detection
     NSString *derived = cursorTypeFromCursorName(className);
     if (derived) {
-        MRLog(@"🎯 Cursor type from class name: %@", derived);
         return derived;
     }
 
     derived = cursorTypeFromCursorName(description);
     if (derived) {
-        MRLog(@"🎯 Cursor type from description: %@", derived);
         return derived;
     }
 
     // Default fallback
-    MRLog(@"⚠️ Unknown cursor type, defaulting to 'default'");
     return @"default";
 }
 
@@ -631,53 +636,71 @@ static NSString* detectSystemCursorType(void) {
         // Try different methods to get current cursor
         if ([NSCursor respondsToSelector:@selector(currentSystemCursor)]) {
             currentCursor = [NSCursor currentSystemCursor];
-            NSLog(@"🖱️ currentSystemCursor: %@", currentCursor ?: @"nil");
         }
 
         if (!currentCursor) {
             currentCursor = [NSCursor currentCursor];
-            NSLog(@"🖱️ currentCursor: %@", currentCursor ?: @"nil");
         }
 
         if (currentCursor) {
             NSString *className = NSStringFromClass([currentCursor class]);
             NSString *description = [currentCursor description];
-            NSLog(@"🖱️ Cursor class: %@, description: %@", className ?: @"nil", description ?: @"nil");
-
-            // Try to identify cursor by hotspot and size (more reliable than pointer equality)
+            // Use more direct cursor detection approach
+            NSImage *cursorImage = [currentCursor image];
             NSPoint hotspot = [currentCursor hotSpot];
-            NSSize cursorSize = [[currentCursor image] size];
-
-            NSLog(@"🎯 Cursor hotspot: (%.1f, %.1f), size: %.1fx%.1f",
-                  hotspot.x, hotspot.y, cursorSize.width, cursorSize.height);
-
-            // Common cursor patterns by hotspot (adjusted for modern macOS cursor sizes)
-            if ((hotspot.x >= 0.0 && hotspot.x <= 3.0) && (hotspot.y >= 0.0 && hotspot.y <= 3.0)) {
-                // Arrow cursor typically has hotspot at top-left corner
-                cursorType = @"default";
-                NSLog(@"🎯 ARROW CURSOR (by hotspot) -> default");
-            } else if ((hotspot.x >= 12.0 && hotspot.x <= 16.0) && (hotspot.y >= 6.0 && hotspot.y <= 10.0)) {
-                // I-beam cursor typically has hotspot around middle
+            NSSize imageSize = [cursorImage size];
+
+            // ROBUST cursor detection - works with any cursor size
+            CGFloat aspectRatio = imageSize.width / imageSize.height;
+            CGFloat relativeHotspotX = hotspot.x / imageSize.width;
+            CGFloat relativeHotspotY = hotspot.y / imageSize.height;
+
+            // Debug: Show proportional analysis
+            NSLog(@"🔍 CURSOR: %.1fx%.1f ratio=%.2f hotspot=(%.2f,%.2f)",
+                  imageSize.width, imageSize.height, aspectRatio, relativeHotspotX, relativeHotspotY);
+
+            // UPDATED with real cursor data:
+            // Arrow: 17x23 ratio=0.74 hotspot=(0.24,0.17)
+            // Text: 9x18 ratio=0.50 hotspot=(0.44,0.50)
+            // Pointer: 32x32 ratio=1.00 hotspot=(0.41,0.25)
+
+            // 1. TEXT/I-BEAM CURSOR - narrow ratio, center hotspot
+            if (aspectRatio >= 0.45 && aspectRatio <= 0.60 && // Narrow (0.50 typical)
+                relativeHotspotX >= 0.35 && relativeHotspotX <= 0.55 && // Center X (0.44 typical)
+                relativeHotspotY >= 0.40 && relativeHotspotY <= 0.60) { // Center Y (0.50 typical)
                 cursorType = @"text";
-                NSLog(@"🎯 IBEAM CURSOR (by hotspot) -> text");
-            } else if ((hotspot.x >= 5.0 && hotspot.x <= 10.0) && (hotspot.y >= 0.0 && hotspot.y <= 4.0)) {
-                // Pointing hand cursor typically has hotspot at finger tip
+            }
+            // 2. ARROW CURSOR - medium ratio, top-left hotspot
+            else if (aspectRatio >= 0.65 && aspectRatio <= 0.85 && // Medium (0.74 typical)
+                     relativeHotspotX >= 0.15 && relativeHotspotX <= 0.35 && // Left side (0.24 typical)
+                     relativeHotspotY >= 0.10 && relativeHotspotY <= 0.25) { // Top area (0.17 typical)
+                cursorType = @"default";
+            }
+            // 3. POINTER CURSOR - square ratio, left-center hotspot
+            else if (aspectRatio >= 0.90 && aspectRatio <= 1.10 && // Square (1.00 typical)
+                     relativeHotspotX >= 0.30 && relativeHotspotX <= 0.50 && // Left-center (0.41 typical)
+                     relativeHotspotY >= 0.15 && relativeHotspotY <= 0.35) { // Upper area (0.25 typical)
                 cursorType = @"pointer";
-                NSLog(@"🎯 POINTING HAND CURSOR (by hotspot) -> pointer");
-            } else {
-                // Fallback to more detailed analysis
-                NSString *derivedType = cursorTypeFromNSCursor(currentCursor);
-                if (derivedType && ![derivedType isEqualToString:@"default"]) {
-                    cursorType = derivedType;
-                    NSLog(@"🎯 SYSTEM CURSOR TYPE (derived): %@", cursorType);
+            }
+            // 4. GRAB CURSOR - square, center hotspot
+            else if (aspectRatio >= 0.90 && aspectRatio <= 1.10 && // Square
+                     relativeHotspotX >= 0.40 && relativeHotspotX <= 0.60 && // Center X
+                     relativeHotspotY >= 0.40 && relativeHotspotY <= 0.60) { // Center Y
+                cursorType = @"grab";
+            }
+            else {
+                // Try to use a different approach - cursor name introspection
+                NSString *derived = cursorTypeFromNSCursor(currentCursor);
+                if (derived && ![derived isEqualToString:@"default"]) {
+                    cursorType = derived;
+                    // NSLog(@"🎯 DERIVED FROM ANALYSIS: %@", cursorType);
                 } else {
-                    // Use accessibility detection if system cursor is generic
                     cursorType = @"default";
-                    NSLog(@"🎯 SYSTEM CURSOR TYPE -> default (will try AX)");
+                    // NSLog(@"🎯 FALLBACK TO DEFAULT (will check AX)");
                 }
             }
         } else {
-            NSLog(@"🖱️ No current cursor found");
+            // NSLog(@"🖱️ No current cursor found");
             cursorType = @"default";
         }
     };
@@ -730,25 +753,33 @@ NSString* getCursorType() {
 
         NSString *finalType = @"default";
 
-        // System cursor has priority since it's more accurate for visual state
-        NSLog(@"🎯 CURSOR DECISION: system='%@', ax='%@'", systemCursorType ?: @"nil", axCursorType ?: @"nil");
-
-        // Use system cursor if available (it's more accurate for visual appearance)
+        // SYSTEM CURSOR FIRST - more reliable for visual state
+        // Always trust system cursor first, only use AX for very specific cases
         if (systemCursorType && [systemCursorType length] > 0) {
-            finalType = systemCursorType;
-            NSLog(@"🎯 Using SYSTEM cursor: %@", finalType);
+            // Only override system cursor with AX if system is "default" AND AX gives us text/resize
+            if ([systemCursorType isEqualToString:@"default"] && axCursorType &&
+                ([axCursorType isEqualToString:@"text"] ||
+                 [axCursorType containsString:@"resize"] ||
+                 [axCursorType isEqualToString:@"crosshair"])) {
+                finalType = axCursorType;
+            } else {
+                finalType = systemCursorType;
+            }
         }
-        // Fallback to AX cursor if system cursor is not available
+        // Only if system completely fails, use AX
         else if (axCursorType && [axCursorType length] > 0) {
             finalType = axCursorType;
-            NSLog(@"🎯 Using AX cursor (fallback): %@", finalType);
         }
-        // Final fallback
         else {
-            NSLog(@"🎯 Fallback to default cursor");
+            finalType = @"default";
         }
 
-        NSLog(@"🎯 FINAL CURSOR TYPE: %@", finalType);
+        // Only log when cursor type changes
+        static NSString *lastLoggedType = nil;
+        if (![finalType isEqualToString:lastLoggedType]) {
+            NSLog(@"🎯 %@", finalType);
+            lastLoggedType = [finalType copy];
+        }
         return finalType;
     }
 }
@@ -1047,80 +1078,58 @@ NSDictionary* getDisplayScalingInfo(CGPoint globalPoint) {
         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);
-            
-            NSLog(@"🔍 Display %u: bounds(%.0f,%.0f %.0fx%.0f), cursor(%.0f,%.0f)", 
-                  displayID, displayBounds.origin.x, displayBounds.origin.y, 
-                  displayBounds.size.width, displayBounds.size.height,
-                  globalPoint.x, globalPoint.y);
-            
-            // CRITICAL FIX: Manual bounds check for better coordinate system compatibility
-            BOOL isInBounds = (globalPoint.x >= displayBounds.origin.x && 
+
+            BOOL isInBounds = (globalPoint.x >= displayBounds.origin.x &&
                               globalPoint.x < displayBounds.origin.x + displayBounds.size.width &&
-                              globalPoint.y >= displayBounds.origin.y && 
+                              globalPoint.y >= displayBounds.origin.y &&
                               globalPoint.y < displayBounds.origin.y + displayBounds.size.height);
-            
-            NSLog(@"🔍 Manual bounds check: %s", isInBounds ? "INSIDE" : "OUTSIDE");
-            
+
             // Check if point is within this display
             if (isInBounds) {
-                // CRITICAL FIX: Get REAL physical dimensions using multiple detection methods
-                // Method 1: CGDisplayCreateImage (may be scaled on some systems)
+                // Get physical dimensions
                 CGImageRef testImage = CGDisplayCreateImage(displayID);
                 CGSize imageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
                 CGImageRelease(testImage);
-                
-                // Method 2: Native display mode detection for true physical resolution
+
                 CGSize actualPhysicalSize = imageSize;
                 CFArrayRef displayModes = CGDisplayCopyAllDisplayModes(displayID, NULL);
                 if (displayModes) {
                     CFIndex modeCount = CFArrayGetCount(displayModes);
                     CGSize maxResolution = CGSizeMake(0, 0);
-                    
-                    // Find the highest resolution mode (native resolution)
+
                     for (CFIndex i = 0; i < modeCount; i++) {
                         CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(displayModes, i);
                         CGSize modeSize = CGSizeMake(CGDisplayModeGetWidth(mode), CGDisplayModeGetHeight(mode));
-                        
-                        if (modeSize.width > maxResolution.width || 
+
+                        if (modeSize.width > maxResolution.width ||
                             (modeSize.width == maxResolution.width && modeSize.height > maxResolution.height)) {
                             maxResolution = modeSize;
                         }
                     }
-                    
-                    // Use the max resolution if it's significantly higher than image size
+
                     if (maxResolution.width > imageSize.width * 1.5 || maxResolution.height > imageSize.height * 1.5) {
                         actualPhysicalSize = maxResolution;
-                        NSLog(@"🔍 Using display mode detection: %.0fx%.0f (was %.0fx%.0f)", 
-                              maxResolution.width, maxResolution.height, imageSize.width, imageSize.height);
                     } else {
                         actualPhysicalSize = imageSize;
-                        NSLog(@"🔍 Using image size detection: %.0fx%.0f", imageSize.width, imageSize.height);
                     }
-                    
+
                     CFRelease(displayModes);
                 } else {
                     actualPhysicalSize = imageSize;
                 }
-                
+
                 CGSize logicalSize = displayBounds.size;
                 CGSize reportedPhysicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
-                
-                NSLog(@"🔍 REAL scaling info:");
-                NSLog(@"   Logical: %.0fx%.0f", logicalSize.width, logicalSize.height);
-                NSLog(@"   Reported physical: %.0fx%.0f", reportedPhysicalSize.width, reportedPhysicalSize.height);
-                NSLog(@"   ACTUAL physical: %.0fx%.0f", actualPhysicalSize.width, actualPhysicalSize.height);
-                
+
                 CGFloat scaleX = actualPhysicalSize.width / logicalSize.width;
                 CGFloat scaleY = actualPhysicalSize.height / logicalSize.height;
                 CGFloat scaleFactor = MAX(scaleX, scaleY);
                 
-                NSLog(@"🔍 REAL scale factors: X=%.2f, Y=%.2f, Final=%.2f", scaleX, scaleY, scaleFactor);
-                
                 return @{
                     @"displayID": @(displayID),
                     @"logicalSize": [NSValue valueWithSize:NSMakeSize(logicalSize.width, logicalSize.height)],
@@ -1131,39 +1140,37 @@ NSDictionary* getDisplayScalingInfo(CGPoint globalPoint) {
             }
         }
         
-        // Fallback to main display with REAL physical dimensions
+        // Fallback to main display
         CGDirectDisplayID mainDisplay = CGMainDisplayID();
         CGRect displayBounds = CGDisplayBounds(mainDisplay);
-        
-        // Get REAL physical dimensions using multiple detection methods
+
         CGImageRef testImage = CGDisplayCreateImage(mainDisplay);
         CGSize imageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
         CGImageRelease(testImage);
-        
-        // Try display mode detection for true native resolution
+
         CGSize actualPhysicalSize = imageSize;
         CFArrayRef displayModes = CGDisplayCopyAllDisplayModes(mainDisplay, NULL);
         if (displayModes) {
             CFIndex modeCount = CFArrayGetCount(displayModes);
             CGSize maxResolution = CGSizeMake(0, 0);
-            
+
             for (CFIndex i = 0; i < modeCount; i++) {
                 CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(displayModes, i);
                 CGSize modeSize = CGSizeMake(CGDisplayModeGetWidth(mode), CGDisplayModeGetHeight(mode));
-                
-                if (modeSize.width > maxResolution.width || 
+
+                if (modeSize.width > maxResolution.width ||
                     (modeSize.width == maxResolution.width && modeSize.height > maxResolution.height)) {
                     maxResolution = modeSize;
                 }
             }
-            
+
             if (maxResolution.width > imageSize.width * 1.5 || maxResolution.height > imageSize.height * 1.5) {
                 actualPhysicalSize = maxResolution;
             }
-            
+
             CFRelease(displayModes);
         }
-        
+
         CGSize logicalSize = displayBounds.size;
         CGFloat scaleFactor = MAX(actualPhysicalSize.width / logicalSize.width, actualPhysicalSize.height / logicalSize.height);
         
@@ -1191,10 +1198,7 @@ Napi::Value GetCursorPosition(const Napi::CallbackInfo& info) {
             CFRelease(event);
         }
         
-        // Get display scaling information
-        NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
         CGPoint logicalLocation = rawLocation;
-        // CGEventGetLocation already returns logical coordinates; additional scaling happens in JS layer.
 
         NSString *cursorType = getCursorType();
         
@@ -1232,27 +1236,11 @@ Napi::Value GetCursorPosition(const Napi::CallbackInfo& info) {
         result.Set("cursorType", Napi::String::New(env, [cursorType UTF8String]));
         result.Set("eventType", Napi::String::New(env, [eventType UTF8String]));
         
-        // Add scaling info for coordinate transformation
+        // Basic display info
+        NSDictionary *scalingInfo = getDisplayScalingInfo(rawLocation);
         if (scalingInfo) {
             CGFloat scaleFactor = [[scalingInfo objectForKey:@"scaleFactor"] doubleValue];
-            NSSize logicalSize = [[scalingInfo objectForKey:@"logicalSize"] sizeValue];
-            NSSize physicalSize = [[scalingInfo objectForKey:@"physicalSize"] sizeValue];
-            NSRect displayBounds = [[scalingInfo objectForKey:@"displayBounds"] rectValue];
-            
             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));
-            
-            // Add display dimension info for JS coordinate transformation
-            Napi::Object displayInfo = Napi::Object::New(env);
-            displayInfo.Set("logicalWidth", Napi::Number::New(env, logicalSize.width));
-            displayInfo.Set("logicalHeight", Napi::Number::New(env, logicalSize.height));
-            displayInfo.Set("physicalWidth", Napi::Number::New(env, physicalSize.width));
-            displayInfo.Set("physicalHeight", Napi::Number::New(env, physicalSize.height));
-            displayInfo.Set("displayX", Napi::Number::New(env, displayBounds.origin.x));
-            displayInfo.Set("displayY", Napi::Number::New(env, displayBounds.origin.y));
-            
-            result.Set("displayInfo", displayInfo);
         }
         
         return result;

package/src/mac_recorder.mm

@@ -591,16 +591,16 @@ Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
         }
         Napi::Array result = Napi::Array::New(env, displays.count);
         
-        NSLog(@"Found %lu displays", (unsigned long)displays.count);
-        
+        // NSLog(@"Found %lu displays", (unsigned long)displays.count);
+
         for (NSUInteger i = 0; i < displays.count; i++) {
             NSDictionary *display = displays[i];
-            NSLog(@"Display %lu: ID=%u, Name=%@, Size=%@x%@", 
-                  (unsigned long)i,
-                  [display[@"id"] unsignedIntValue],
-                  display[@"name"],
-                  display[@"width"],
-                  display[@"height"]);
+            // NSLog(@"Display %lu: ID=%u, Name=%@, Size=%@x%@",
+            //       (unsigned long)i,
+            //       [display[@"id"] unsignedIntValue],
+            //       display[@"name"],
+            //       display[@"width"],
+            //       display[@"height"]);
                   
             Napi::Object displayObj = Napi::Object::New(env);
             displayObj.Set("id", Napi::Number::New(env, [display[@"id"] unsignedIntValue]));