node-mac-recorder 2.17.11 → 2.17.13

package/.claude/settings.local.json

@@ -4,7 +4,9 @@
       "Bash(node:*)",
       "Bash(chmod:*)",
       "Bash(cat:*)",
-      "Bash(git checkout:*)"
+      "Bash(git checkout:*)",
+      "WebSearch",
+      "WebFetch(domain:stackoverflow.com)"
     ],
     "deny": [],
     "ask": []

package/package.json

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

package/src/cursor_tracker.mm

@@ -35,9 +35,17 @@ NSDictionary* getDisplayScalingInfo(CGPoint globalPoint);
 
 static CursorTimerTarget *g_timerTarget = nil;
 
-// Global cursor state tracking
+// Enhanced cursor state tracking with stability
 static NSString *g_lastDetectedCursorType = nil;
+static NSString *g_stableCursorType = @"default";
 static int g_cursorTypeCounter = 0;
+static NSTimeInterval g_lastCursorCheckTime = 0;
+static int g_sameCursorDetectionCount = 0;
+static NSString *g_pendingCursorType = nil;
+
+// Cursor stability constants
+static const NSTimeInterval CURSOR_STABILITY_THRESHOLD = 0.1; // 100ms
+static const int CURSOR_CONFIRMATION_COUNT = 2; // Need 2 consecutive detections
 
 // Mouse button state tracking
 static bool g_leftMouseDown = false;
@@ -49,255 +57,246 @@ static CGEventRef eventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEv
     return event;
 }
 
-// Cursor type detection helper - sistem genelindeki cursor type'ı al
+// Enhanced cursor type detection with better NSCursor analysis
+NSString* detectCursorTypeFromNSCursor() {
+    @try {
+        NSCursor *currentCursor = [NSCursor currentSystemCursor];
+        if (!currentCursor) {
+            return nil; // Return nil to indicate we should try other methods
+        }
+
+        // Compare with known system cursors using identity comparison
+        if (currentCursor == [NSCursor arrowCursor]) {
+            return @"default";
+        } else if (currentCursor == [NSCursor IBeamCursor]) {
+            return @"text";
+        } else if (currentCursor == [NSCursor pointingHandCursor]) {
+            return @"pointer";
+        } else if (currentCursor == [NSCursor resizeLeftRightCursor]) {
+            return @"col-resize";
+        } else if (currentCursor == [NSCursor resizeUpDownCursor]) {
+            return @"ns-resize";
+        } else if (currentCursor == [NSCursor crosshairCursor]) {
+            return @"crosshair";
+        } else if (currentCursor == [NSCursor openHandCursor]) {
+            return @"grab";
+        } else if (currentCursor == [NSCursor closedHandCursor]) {
+            return @"grabbing";
+        } else if (currentCursor == [NSCursor operationNotAllowedCursor]) {
+            return @"not-allowed";
+        }
+
+        // Check for additional resize cursors using image analysis
+        NSImage *cursorImage = [currentCursor image];
+        if (cursorImage) {
+            NSSize imageSize = [cursorImage size];
+            NSPoint hotSpot = [currentCursor hotSpot];
+
+            // Analyze cursor image to detect resize cursors
+            if (imageSize.width > 10 && imageSize.height > 10) {
+                // Check for diagonal resize cursors (corner resize)
+                if (imageSize.width >= 15 && imageSize.height >= 15) {
+                    // These are likely diagonal resize cursors
+                    // hotSpot can help distinguish between nwse and nesw
+                    if (hotSpot.x < imageSize.width / 2 && hotSpot.y < imageSize.height / 2) {
+                        return @"nwse-resize"; // northwest-southeast
+                    } else if (hotSpot.x > imageSize.width / 2 && hotSpot.y < imageSize.height / 2) {
+                        return @"nesw-resize"; // northeast-southwest
+                    }
+                }
+
+                // Check for horizontal/vertical resize cursors
+                if (imageSize.width > imageSize.height + 5) {
+                    return @"col-resize"; // horizontal resize
+                } else if (imageSize.height > imageSize.width + 5) {
+                    return @"ns-resize"; // vertical resize
+                }
+            }
+
+            // Text cursors typically have I-beam shape (narrow width)
+            if (imageSize.width < 8 && imageSize.height > 15) {
+                return @"text";
+            }
+        }
+
+        // Return nil to indicate we should use contextual detection
+        return nil;
+    } @catch (NSException *exception) {
+        return nil;
+    }
+}
+
+// Improved cursor type detection with stability and multi-layer approach
 NSString* getCursorType() {
     @autoreleasepool {
         g_cursorTypeCounter++;
-        
+        NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
+
         @try {
-            // ACCESSIBILITY API BASED CURSOR DETECTION
-            // Determine cursor type based on the UI element under the cursor
+            // Layer 1: Fast NSCursor detection (high confidence cases)
+            NSString *nsCursorType = detectCursorTypeFromNSCursor();
+
+            // Layer 2: Contextual detection using Accessibility API
+            NSString *contextualCursorType = nil;
 
             CGPoint cursorPos = CGEventGetLocation(CGEventCreate(NULL));
             AXUIElementRef systemWide = AXUIElementCreateSystemWide();
             AXUIElementRef elementAtPosition = NULL;
             AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
 
-            NSString *cursorType = @"default"; // Default fallback
-
             if (error == kAXErrorSuccess && elementAtPosition) {
                 CFStringRef role = NULL;
                 error = AXUIElementCopyAttributeValue(elementAtPosition, kAXRoleAttribute, (CFTypeRef*)&role);
 
                 if (error == kAXErrorSuccess && role) {
                     NSString *elementRole = (__bridge_transfer NSString*)role;
-                    NSLog(@"🎯 ELEMENT ROLE: %@", elementRole);
 
-                    // TEXT CURSORS
+                    // TEXT CURSORS - high priority
                     if ([elementRole isEqualToString:@"AXTextField"] ||
                         [elementRole isEqualToString:@"AXTextArea"] ||
-                        [elementRole isEqualToString:@"AXStaticText"] ||
                         [elementRole isEqualToString:@"AXSearchField"]) {
-                        cursorType = @"text";
+                        contextualCursorType = @"text";
                     }
-                    // POINTER CURSORS (clickable elements)
+                    // POINTER CURSORS - only for interactive elements
                     else if ([elementRole isEqualToString:@"AXLink"] ||
                              [elementRole isEqualToString:@"AXButton"] ||
                              [elementRole isEqualToString:@"AXMenuItem"] ||
                              [elementRole isEqualToString:@"AXRadioButton"] ||
-                             [elementRole isEqualToString:@"AXCheckBox"] ||
-                             [elementRole isEqualToString:@"AXPopUpButton"] ||
-                             [elementRole isEqualToString:@"AXTab"]) {
-                        cursorType = @"pointer";
+                             [elementRole isEqualToString:@"AXCheckBox"]) {
+                        contextualCursorType = @"pointer";
                     }
-                    // GRAB CURSORS (draggable elements)
-                    else if ([elementRole isEqualToString:@"AXImage"] ||
-                             [elementRole isEqualToString:@"AXGroup"]) {
-                        // Check if element is draggable
-                        CFBooleanRef draggable = NULL;
-                        error = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXMovable"), (CFTypeRef*)&draggable);
-                        if (error == kAXErrorSuccess && draggable && CFBooleanGetValue(draggable)) {
-                            cursorType = @"grab";
-                        } else {
-                            cursorType = @"default";
+                    // WINDOW BORDER RESIZE - critical for resize detection
+                    else if ([elementRole isEqualToString:@"AXWindow"]) {
+                        CFTypeRef position = NULL;
+                        CFTypeRef size = NULL;
+                        AXError posErr = AXUIElementCopyAttributeValue(elementAtPosition, kAXPositionAttribute, &position);
+                        AXError sizeErr = AXUIElementCopyAttributeValue(elementAtPosition, kAXSizeAttribute, &size);
+
+                        if (posErr == kAXErrorSuccess && sizeErr == kAXErrorSuccess && position && size) {
+                            CGPoint windowPos;
+                            CGSize windowSize;
+                            AXValueGetValue((AXValueRef)position, kAXValueTypeCGPoint, &windowPos);
+                            AXValueGetValue((AXValueRef)size, kAXValueTypeCGSize, &windowSize);
+
+                            CGFloat x = cursorPos.x - windowPos.x;
+                            CGFloat y = cursorPos.y - windowPos.y;
+                            CGFloat w = windowSize.width;
+                            CGFloat h = windowSize.height;
+                            CGFloat edge = 5.0; // 5px edge detection
+
+                            // Corner resize detection
+                            if (x <= edge && y <= edge) {
+                                contextualCursorType = @"nwse-resize";
+                            }
+                            else if (x >= w-edge && y <= edge) {
+                                contextualCursorType = @"nesw-resize";
+                            }
+                            else if (x <= edge && y >= h-edge) {
+                                contextualCursorType = @"nesw-resize";
+                            }
+                            else if (x >= w-edge && y >= h-edge) {
+                                contextualCursorType = @"nwse-resize";
+                            }
+                            // Edge resize detection
+                            else if (x <= edge || x >= w-edge) {
+                                contextualCursorType = @"col-resize";
+                            }
+                            else if (y <= edge || y >= h-edge) {
+                                contextualCursorType = @"ns-resize";
+                            }
+
+                            if (position) CFRelease(position);
+                            if (size) CFRelease(size);
                         }
                     }
-                    // PROGRESS CURSORS (loading/busy elements)
-                    else if ([elementRole isEqualToString:@"AXProgressIndicator"] ||
-                             [elementRole isEqualToString:@"AXBusyIndicator"]) {
-                        cursorType = @"progress";
-                    }
-                    // HELP CURSORS (help buttons/tooltips)
-                    else if ([elementRole isEqualToString:@"AXHelpTag"] ||
-                             [elementRole isEqualToString:@"AXTooltip"]) {
-                        cursorType = @"help";
-                    }
-                    // RESIZE CURSORS - sadece AXSplitter için
+                    // SPLITTER RESIZE
                     else if ([elementRole isEqualToString:@"AXSplitter"]) {
-                        // Get splitter orientation to determine resize direction
                         CFStringRef orientation = NULL;
                         error = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXOrientation"), (CFTypeRef*)&orientation);
                         if (error == kAXErrorSuccess && orientation) {
                             NSString *orientationStr = (__bridge_transfer NSString*)orientation;
                             if ([orientationStr isEqualToString:@"AXHorizontalOrientation"]) {
-                                cursorType = @"ns-resize"; // Yatay splitter -> dikey hareket (north-south)
+                                contextualCursorType = @"ns-resize";
                             } else if ([orientationStr isEqualToString:@"AXVerticalOrientation"]) {
-                                cursorType = @"col-resize"; // Dikey splitter -> yatay hareket (east-west)
-                            } else {
-                                cursorType = @"default"; // Bilinmeyen orientation
+                                contextualCursorType = @"col-resize";
                             }
-                        } else {
-                            cursorType = @"default"; // Orientation alınamazsa default
                         }
                     }
-                    // SCROLL CURSORS - hep default olsun, all-scroll görünmesin
-                    else if ([elementRole isEqualToString:@"AXScrollBar"]) {
-                        cursorType = @"default"; // ScrollBar'lar için de default
-                    }
-                    // AXScrollArea - hep default
-                    else if ([elementRole isEqualToString:@"AXScrollArea"]) {
-                        cursorType = @"default"; // ScrollArea her zaman default
-                    }
-                    // CROSSHAIR CURSORS (drawing/selection tools)
-                    else if ([elementRole isEqualToString:@"AXCanvas"] ||
-                             [elementRole isEqualToString:@"AXDrawingArea"]) {
-                        cursorType = @"crosshair";
-                    }
-                    // ZOOM CURSORS (zoom controls)
-                    else if ([elementRole isEqualToString:@"AXZoomButton"]) {
-                        cursorType = @"zoom-in";
+                    // PROGRESS INDICATORS
+                    else if ([elementRole isEqualToString:@"AXProgressIndicator"]) {
+                        contextualCursorType = @"progress";
                     }
-                    // NOT-ALLOWED CURSORS (disabled elements)
-                    else if ([elementRole isEqualToString:@"AXStaticText"] ||
-                             [elementRole isEqualToString:@"AXGroup"]) {
-                        // Check if element is disabled/readonly
-                        CFBooleanRef enabled = NULL;
-                        error = AXUIElementCopyAttributeValue(elementAtPosition, kAXEnabledAttribute, (CFTypeRef*)&enabled);
-                        if (error == kAXErrorSuccess && enabled && !CFBooleanGetValue(enabled)) {
-                            cursorType = @"not-allowed";
-                        }
-                    }
-                    // WINDOW BORDER RESIZE - sadece pencere kenarlarında
-                    else if ([elementRole isEqualToString:@"AXWindow"]) {
-                        // Check window attributes to see if it's resizable
-                        CFBooleanRef resizable = NULL;
-                        AXError resizableError = AXUIElementCopyAttributeValue(elementAtPosition, CFSTR("AXResizeButton"), (CFTypeRef*)&resizable);
-
-                        // Sadece resize edilebilir pencereler için cursor değişimi
-                        if (resizableError == kAXErrorSuccess || true) { // AXResizeButton bulunamazsa da devam et
-                            CFTypeRef position = NULL;
-                            CFTypeRef size = NULL;
-                            error = AXUIElementCopyAttributeValue(elementAtPosition, kAXPositionAttribute, &position);
-                            AXError sizeError = AXUIElementCopyAttributeValue(elementAtPosition, kAXSizeAttribute, &size);
-
-                            if (error == kAXErrorSuccess && sizeError == kAXErrorSuccess && position && size) {
-                                CGPoint windowPos;
-                                CGSize windowSize;
-                                AXValueGetValue((AXValueRef)position, kAXValueTypeCGPoint, &windowPos);
-                                AXValueGetValue((AXValueRef)size, kAXValueTypeCGSize, &windowSize);
-
-                                CGFloat x = cursorPos.x - windowPos.x;
-                                CGFloat y = cursorPos.y - windowPos.y;
-                                CGFloat w = windowSize.width;
-                                CGFloat h = windowSize.height;
-                                CGFloat edge = 3.0; // Daha küçük edge detection (3px)
-
-                                // Sadece çok kenar köşelerde resize cursor'ı göster
-                                BOOL isOnBorder = NO;
-
-                                // Corner resize detection - çok dar alanda, doğru açılar
-                                if (x <= edge && y <= edge) {
-                                    cursorType = @"nwse-resize"; // Sol üst köşe - northwest-southeast
-                                    isOnBorder = YES;
-                                }
-                                else if (x >= w-edge && y <= edge) {
-                                    cursorType = @"nesw-resize"; // Sağ üst köşe - northeast-southwest
-                                    isOnBorder = YES;
-                                }
-                                else if (x <= edge && y >= h-edge) {
-                                    cursorType = @"nesw-resize"; // Sol alt köşe - southwest-northeast
-                                    isOnBorder = YES;
-                                }
-                                else if (x >= w-edge && y >= h-edge) {
-                                    cursorType = @"nwse-resize"; // Sağ alt köşe - southeast-northwest
-                                    isOnBorder = YES;
-                                }
-                                // Edge resize detection - sadece çok kenarlarda
-                                else if (x <= edge && y > edge && y < h-edge) {
-                                    cursorType = @"col-resize"; // Sol kenar - column resize (yatay)
-                                    isOnBorder = YES;
-                                }
-                                else if (x >= w-edge && y > edge && y < h-edge) {
-                                    cursorType = @"col-resize"; // Sağ kenar - column resize (yatay)
-                                    isOnBorder = YES;
-                                }
-                                else if (y <= edge && x > edge && x < w-edge) {
-                                    cursorType = @"ns-resize"; // Üst kenar - north-south resize (dikey)
-                                    isOnBorder = YES;
-                                }
-                                else if (y >= h-edge && x > edge && x < w-edge) {
-                                    cursorType = @"ns-resize"; // Alt kenar - north-south resize (dikey)
-                                    isOnBorder = YES;
-                                }
-
-                                // Eğer border'da değilse default
-                                if (!isOnBorder) {
-                                    cursorType = @"default";
-                                }
-
-                                if (position) CFRelease(position);
-                                if (size) CFRelease(size);
-                            } else {
-                                cursorType = @"default";
-                            }
-                        } else {
-                            cursorType = @"default";
-                        }
-                    }
-                    // HER DURUM İÇİN DEFAULT FALLBACK
+                    // OTHER ELEMENTS - be conservative, don't assume pointer
                     else {
-                        // Bilinmeyen elementler için her zaman default
-                        cursorType = @"default";
-                    }
-
-                    // Check subroles for additional context
-                    CFStringRef subrole = NULL;
-                    error = AXUIElementCopyAttributeValue(elementAtPosition, kAXSubroleAttribute, (CFTypeRef*)&subrole);
-                    if (error == kAXErrorSuccess && subrole) {
-                        NSString *elementSubrole = (__bridge_transfer NSString*)subrole;
-                        NSLog(@"🎯 ELEMENT SUBROLE: %@", elementSubrole);
-
-                        // Subrole override'ları - sadece çok spesifik durumlar için
-                        if ([elementSubrole isEqualToString:@"AXCloseButton"] ||
-                            [elementSubrole isEqualToString:@"AXMinimizeButton"] ||
-                            [elementSubrole isEqualToString:@"AXZoomButton"] ||
-                            [elementSubrole isEqualToString:@"AXToolbarButton"]) {
-                            cursorType = @"pointer";
-                        }
-                        // Copy/alias subroles - sadece bu durumlar için override
-                        else if ([elementSubrole isEqualToString:@"AXFileDrop"] ||
-                                 [elementSubrole isEqualToString:@"AXDropTarget"]) {
-                            cursorType = @"copy";
-                        }
-                        // Alias/shortcut subroles
-                        else if ([elementSubrole isEqualToString:@"AXAlias"] ||
-                                 [elementSubrole isEqualToString:@"AXShortcut"]) {
-                            cursorType = @"alias";
-                        }
-                        // Grabbing state (being dragged) - sadece gerçek drag sırasında
-                        else if ([elementSubrole isEqualToString:@"AXDragging"] ||
-                                 [elementSubrole isEqualToString:@"AXMoving"]) {
-                            cursorType = @"grabbing";
-                        }
-                        // Zoom controls - sadece spesifik zoom butonları için
-                        else if ([elementSubrole isEqualToString:@"AXZoomIn"]) {
-                            cursorType = @"zoom-in";
-                        }
-                        else if ([elementSubrole isEqualToString:@"AXZoomOut"]) {
-                            cursorType = @"zoom-out";
-                        }
-                        // Subrole'dan bir şey bulamazsa role-based cursor'ı koruyoruz
+                        // Don't override NSCursor for unknown elements
+                        contextualCursorType = nil;
                     }
                 }
-
                 CFRelease(elementAtPosition);
             }
+            if (systemWide) CFRelease(systemWide);
+
+            // Layer 3: Intelligent fusion of NSCursor and contextual results
+            NSString *detectedCursorType = @"default";
+
+            // Priority logic:
+            // 1. If contextual gives resize cursor, always use it (resize has highest priority)
+            if (contextualCursorType != nil &&
+                ([contextualCursorType hasSuffix:@"resize"] ||
+                 [contextualCursorType isEqualToString:@"col-resize"] ||
+                 [contextualCursorType isEqualToString:@"ns-resize"])) {
+                detectedCursorType = contextualCursorType;
+            }
+            // 2. If NSCursor gives a definitive answer and no resize context, use it
+            else if (nsCursorType != nil) {
+                detectedCursorType = nsCursorType;
+            }
+            // 3. If NSCursor is nil/unknown, but contextual is available, use contextual
+            else if (contextualCursorType != nil) {
+                detectedCursorType = contextualCursorType;
+            }
+
+            // Layer 4: Stability filtering to prevent oscillation
 
-            if (systemWide) {
-                CFRelease(systemWide);
+            // Time-based stability check
+            if (currentTime - g_lastCursorCheckTime > CURSOR_STABILITY_THRESHOLD) {
+                // Enough time has passed, reset counters
+                g_sameCursorDetectionCount = 0;
+                g_pendingCursorType = detectedCursorType;
             }
 
-            // Son güvence - eğer cursorType hala nil veya geçersizse default'a çevir
-            if (!cursorType || [cursorType length] == 0) {
-                cursorType = @"default";
+            // Check if detected cursor matches pending cursor
+            if ([detectedCursorType isEqualToString:g_pendingCursorType]) {
+                g_sameCursorDetectionCount++;
+
+                // If we have enough confirmations, update stable cursor
+                if (g_sameCursorDetectionCount >= CURSOR_CONFIRMATION_COUNT) {
+                    g_stableCursorType = detectedCursorType;
+                    g_lastDetectedCursorType = detectedCursorType;
+                }
+            } else {
+                // Different cursor detected, start new pending
+                g_pendingCursorType = detectedCursorType;
+                g_sameCursorDetectionCount = 1;
             }
 
-            NSLog(@"🎯 FINAL CURSOR TYPE: %@", cursorType);
-            return cursorType;
-            
+            g_lastCursorCheckTime = currentTime;
+
+            // Final validation
+            NSString *finalCursorType = g_stableCursorType;
+            if (!finalCursorType || [finalCursorType length] == 0) {
+                finalCursorType = @"default";
+            }
+
+            // Debug logging for stability tracking
+            NSLog(@"🎯 CURSOR DETECTION - NSCursor: %@, Contextual: %@, Stable: %@, Count: %d",
+                  nsCursorType, contextualCursorType, finalCursorType, g_sameCursorDetectionCount);
+
+            return finalCursorType;
+
         } @catch (NSException *exception) {
             NSLog(@"Error in getCursorType: %@", exception);
-            return @"default";
+            return g_stableCursorType ?: @"default";
         }
     }
 }
@@ -501,7 +500,11 @@ void cleanupCursorTracking() {
     g_outputPath = nil;
     g_debugCallbackCount = 0;
     g_lastDetectedCursorType = nil;
+    g_stableCursorType = @"default";
     g_cursorTypeCounter = 0;
+    g_lastCursorCheckTime = 0;
+    g_sameCursorDetectionCount = 0;
+    g_pendingCursorType = nil;
     g_isFirstWrite = true;
 }