node-mac-recorder 2.19.5 → 2.20.1

package/.claude/settings.local.json

@@ -1,12 +1,8 @@
 {
   "permissions": {
     "allow": [
-      "Bash(npm test)",
-      "Bash(node:*)",
-      "Bash(npm install)",
-      "Bash(npm run clean:*)",
-      "Bash(npm run build:*)",
-      "Bash(npm run rebuild:*)"
+      "Bash(node-gyp:*)",
+      "Bash(node:*)"
     ],
     "deny": [],
     "ask": []

package/package.json

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

package/src/cursor_tracker.mm

@@ -5,6 +5,7 @@
 #import <ApplicationServices/ApplicationServices.h>
 #import <Carbon/Carbon.h>
 #import <Accessibility/Accessibility.h>
+#import <dispatch/dispatch.h>
 
 // Global state for cursor tracking
 static bool g_isCursorTracking = false;
@@ -49,16 +50,13 @@ static CGEventRef eventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEv
     return event;
 }
 
-// Cursor type detection helper - sistem genelindeki cursor type'ı al
-NSString* getCursorType() {
+// Accessibility tabanlı cursor tip tespiti
+static NSString* detectCursorTypeUsingAccessibility(CGPoint cursorPos) {
     @autoreleasepool {
-        g_cursorTypeCounter++;
-        
         @try {
             // ACCESSIBILITY API BASED CURSOR DETECTION
             // Determine cursor type based on the UI element under the cursor
 
-            CGPoint cursorPos = CGEventGetLocation(CGEventCreate(NULL));
             AXUIElementRef systemWide = AXUIElementCreateSystemWide();
             AXUIElementRef elementAtPosition = NULL;
             AXError error = AXUIElementCopyElementAtPosition(systemWide, cursorPos.x, cursorPos.y, &elementAtPosition);
@@ -280,9 +278,11 @@ NSString* getCursorType() {
                     }
                 }
 
-                CFRelease(elementAtPosition);
             }
 
+            if (elementAtPosition) {
+                CFRelease(elementAtPosition);
+            }
             if (systemWide) {
                 CFRelease(systemWide);
             }
@@ -292,16 +292,244 @@ NSString* getCursorType() {
                 cursorType = @"default";
             }
 
-            NSLog(@"🎯 FINAL CURSOR TYPE: %@", cursorType);
+            NSLog(@"🎯 AX CURSOR TYPE: %@", cursorType);
             return cursorType;
             
         } @catch (NSException *exception) {
-            NSLog(@"Error in getCursorType: %@", exception);
+            NSLog(@"Error in detectCursorTypeUsingAccessibility: %@", exception);
             return @"default";
         }
     }
 }
 
+static NSString* cursorTypeFromCursorName(NSString *value) {
+    if (!value || [value length] == 0) {
+        return nil;
+    }
+
+    NSString *normalized = [[value stringByReplacingOccurrencesOfString:@"_" withString:@"-"] lowercaseString];
+
+    if ([normalized containsString:@"arrow"]) {
+        return @"default";
+    }
+    if ([normalized containsString:@"ibeam"] ||
+        [normalized containsString:@"insertion"] ||
+        [normalized containsString:@"text"]) {
+        return @"text";
+    }
+    if ([normalized containsString:@"openhand"]) {
+        return @"grab";
+    }
+    if ([normalized containsString:@"closedhand"]) {
+        return @"grabbing";
+    }
+    if ([normalized containsString:@"pointing"] ||
+        ([normalized containsString:@"hand"] && ![normalized containsString:@"closed"])) {
+        return @"pointer";
+    }
+    if ([normalized containsString:@"crosshair"]) {
+        return @"crosshair";
+    }
+    if ([normalized containsString:@"not-allowed"] ||
+        [normalized containsString:@"notallowed"] ||
+        [normalized containsString:@"forbidden"]) {
+        return @"not-allowed";
+    }
+    if ([normalized containsString:@"dragcopy"] || [normalized containsString:@"copy"]) {
+        return @"copy";
+    }
+    if ([normalized containsString:@"draglink"] || [normalized containsString:@"alias"]) {
+        return @"alias";
+    }
+    if ([normalized containsString:@"context"] && [normalized containsString:@"menu"]) {
+        return @"context-menu";
+    }
+    if ([normalized containsString:@"zoom"]) {
+        if ([normalized containsString:@"out"]) {
+            return @"zoom-out";
+        }
+        return @"zoom-in";
+    }
+    if ([normalized containsString:@"resize"] || [normalized containsString:@"size"]) {
+        BOOL diagonalUp = [normalized containsString:@"diagonalup"] || [normalized containsString:@"nesw"];
+        BOOL diagonalDown = [normalized containsString:@"diagonaldown"] || [normalized containsString:@"nwse"];
+        BOOL horizontal = [normalized containsString:@"leftright"] ||
+                          [normalized containsString:@"horizontal"] ||
+                          ([normalized containsString:@"left"] && [normalized containsString:@"right"]);
+        BOOL vertical = [normalized containsString:@"updown"] ||
+                        [normalized containsString:@"vertical"] ||
+                        ([normalized containsString:@"up"] && [normalized containsString:@"down"]);
+
+        if (diagonalUp) {
+            return @"nesw-resize";
+        }
+        if (diagonalDown) {
+            return @"nwse-resize";
+        }
+        if (vertical) {
+            return @"ns-resize";
+        }
+        if (horizontal) {
+            return @"col-resize";
+        }
+    }
+
+    return nil;
+}
+
+static NSString* cursorTypeFromNSCursor(NSCursor *cursor) {
+    if (!cursor) {
+        return nil;
+    }
+
+    if (cursor == [NSCursor arrowCursor]) {
+        return @"default";
+    }
+    if (cursor == [NSCursor IBeamCursor]) {
+        return @"text";
+    }
+    if ([NSCursor respondsToSelector:@selector(IBeamCursorForVerticalLayout)] &&
+        cursor == [NSCursor IBeamCursorForVerticalLayout]) {
+        return @"text";
+    }
+    if (cursor == [NSCursor pointingHandCursor]) {
+        return @"pointer";
+    }
+    if (cursor == [NSCursor crosshairCursor]) {
+        return @"crosshair";
+    }
+    if (cursor == [NSCursor openHandCursor]) {
+        return @"grab";
+    }
+    if (cursor == [NSCursor closedHandCursor]) {
+        return @"grabbing";
+    }
+    if (cursor == [NSCursor operationNotAllowedCursor]) {
+        return @"not-allowed";
+    }
+    if (cursor == [NSCursor dragCopyCursor]) {
+        return @"copy";
+    }
+    if (cursor == [NSCursor dragLinkCursor]) {
+        return @"alias";
+    }
+    if (cursor == [NSCursor contextualMenuCursor]) {
+        return @"context-menu";
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeLeftRightCursor)] &&
+        (cursor == [NSCursor resizeLeftRightCursor] ||
+         cursor == [NSCursor resizeLeftCursor] ||
+         cursor == [NSCursor resizeRightCursor])) {
+        return @"col-resize";
+    }
+    if ([NSCursor respondsToSelector:@selector(resizeUpDownCursor)] &&
+        (cursor == [NSCursor resizeUpDownCursor] ||
+         cursor == [NSCursor resizeUpCursor] ||
+         cursor == [NSCursor resizeDownCursor])) {
+        return @"ns-resize";
+    }
+    if ([NSCursor respondsToSelector:@selector(disappearingItemCursor)] &&
+        cursor == [NSCursor disappearingItemCursor]) {
+        return @"default";
+    }
+
+    NSString *derived = cursorTypeFromCursorName(NSStringFromClass([cursor class]));
+    if (derived) {
+        return derived;
+    }
+
+    derived = cursorTypeFromCursorName([cursor description]);
+    if (derived) {
+        return derived;
+    }
+
+    return nil;
+}
+
+static NSString* detectSystemCursorType(void) {
+    __block NSString *cursorType = nil;
+
+    void (^fetchCursorBlock)(void) = ^{
+        NSCursor *currentCursor = nil;
+        if ([NSCursor respondsToSelector:@selector(currentSystemCursor)]) {
+            currentCursor = [NSCursor currentSystemCursor];
+        }
+        if (!currentCursor) {
+            currentCursor = [NSCursor currentCursor];
+        }
+
+        NSString *derivedType = cursorTypeFromNSCursor(currentCursor);
+        if (derivedType) {
+            cursorType = derivedType;
+        } else if (currentCursor) {
+            cursorType = @"default";
+        }
+
+        NSLog(@"🎯 SYSTEM CURSOR TYPE: %@", cursorType ? cursorType : @"(nil)");
+    };
+
+    if ([NSThread isMainThread]) {
+        fetchCursorBlock();
+    } else {
+        dispatch_sync(dispatch_get_main_queue(), fetchCursorBlock);
+    }
+
+    return cursorType;
+}
+
+NSString* getCursorType() {
+    @autoreleasepool {
+        g_cursorTypeCounter++;
+
+        NSString *systemCursorType = detectSystemCursorType();
+        if (systemCursorType && ![systemCursorType isEqualToString:@"default"]) {
+            NSLog(@"🎯 FINAL CURSOR TYPE: %@", systemCursorType);
+            return systemCursorType;
+        }
+
+        NSString *axCursorType = nil;
+        BOOL hasCursorPosition = NO;
+        CGPoint cursorPos = CGPointZero;
+
+        CGEventRef event = CGEventCreate(NULL);
+        if (event) {
+            cursorPos = CGEventGetLocation(event);
+            hasCursorPosition = YES;
+            CFRelease(event);
+        }
+
+        if (!hasCursorPosition) {
+            if ([NSThread isMainThread]) {
+                cursorPos = [NSEvent mouseLocation];
+                hasCursorPosition = YES;
+            } else {
+                __block CGPoint fallbackPos = CGPointZero;
+                dispatch_sync(dispatch_get_main_queue(), ^{
+                    fallbackPos = [NSEvent mouseLocation];
+                });
+                cursorPos = fallbackPos;
+                hasCursorPosition = YES;
+            }
+        }
+
+        if (hasCursorPosition) {
+            axCursorType = detectCursorTypeUsingAccessibility(cursorPos);
+        }
+
+        NSString *finalType = nil;
+        if (axCursorType && ![axCursorType isEqualToString:@"default"]) {
+            finalType = axCursorType;
+        } else if (systemCursorType && [systemCursorType length] > 0) {
+            finalType = systemCursorType;
+        } else {
+            finalType = @"default";
+        }
+
+        NSLog(@"🎯 FINAL CURSOR TYPE: %@", finalType);
+        return finalType;
+    }
+}
+
 // Dosyaya yazma helper fonksiyonu
 void writeToFile(NSDictionary *cursorData) {
     @autoreleasepool {
@@ -860,4 +1088,4 @@ Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports) {
     exports.Set("getCursorTrackingStatus", Napi::Function::New(env, GetCursorTrackingStatus));
     
     return exports;
-} 
+} 

package/src/screen_capture_kit.mm

@@ -2,7 +2,7 @@
 
 // Pure ScreenCaptureKit implementation - NO AVFoundation
 static SCStream * API_AVAILABLE(macos(12.3)) g_stream = nil;
-static id g_recordingOutput API_AVAILABLE(macos(15.0)) = nil;
+static SCRecordingOutput * API_AVAILABLE(macos(15.0)) g_recordingOutput = nil;
 static id<SCStreamDelegate> API_AVAILABLE(macos(12.3)) g_streamDelegate = nil;
 static BOOL g_isRecording = NO;
 static BOOL g_isCleaningUp = NO;  // Prevent recursive cleanup
@@ -42,8 +42,7 @@ static NSString *g_outputPath = nil;
 
 + (BOOL)isScreenCaptureKitAvailable {
     if (@available(macOS 15.0, *)) {
-        Class recordingOutputClass = NSClassFromString(@"SCRecordingOutput");
-        return [SCShareableContent class] != nil && [SCStream class] != nil && recordingOutputClass != nil;
+        return [SCShareableContent class] != nil && [SCStream class] != nil && [SCRecordingOutput class] != nil;
     }
     return NO;
 }
@@ -276,23 +275,17 @@ static NSString *g_outputPath = nil;
         }
         
         if (@available(macOS 15.0, *)) {
-            // Create recording output configuration using runtime class lookup
-            Class recordingConfigClass = NSClassFromString(@"SCRecordingOutputConfiguration");
-            Class recordingOutputClass = NSClassFromString(@"SCRecordingOutput");
-
-            if (recordingConfigClass && recordingOutputClass) {
-                id recordingConfig = [[recordingConfigClass alloc] init];
-                [recordingConfig setValue:outputURL forKey:@"outputURL"];
-                // Use string constant for video codec
-                [recordingConfig setValue:@"avc1" forKey:@"videoCodecType"];
-
-                // Audio configuration - using available properties
-                // Note: Specific audio routing handled by ScreenCaptureKit automatically
-
-                // Create recording output with correct initializer
-                g_recordingOutput = [[recordingOutputClass alloc] initWithConfiguration:recordingConfig
-                                                                            delegate:nil];
-            }
+            // Create recording output configuration
+            SCRecordingOutputConfiguration *recordingConfig = [[SCRecordingOutputConfiguration alloc] init];
+            recordingConfig.outputURL = outputURL;
+            recordingConfig.videoCodecType = AVVideoCodecTypeH264;
+            
+            // Audio configuration - using available properties
+            // Note: Specific audio routing handled by ScreenCaptureKit automatically
+            
+            // Create recording output with correct initializer
+            g_recordingOutput = [[SCRecordingOutput alloc] initWithConfiguration:recordingConfig 
+                                                                        delegate:nil];
             if (shouldCaptureMic && shouldCaptureSystemAudio) {
                 NSLog(@"🔧 Created SCRecordingOutput with microphone and system audio");
             } else if (shouldCaptureMic) {
@@ -327,9 +320,7 @@ static NSString *g_outputPath = nil;
         BOOL outputAdded = NO;
         
         if (@available(macOS 15.0, *)) {
-            if (g_recordingOutput && [g_stream respondsToSelector:@selector(addRecordingOutput:error:)]) {
-                outputAdded = [g_stream addRecordingOutput:g_recordingOutput error:&outputError];
-            }
+            outputAdded = [g_stream addRecordingOutput:g_recordingOutput error:&outputError];
         }
         
         if (!outputAdded || outputError) {