node-mac-recorder 2.22.24 → 2.22.33

package/src/electron_safe/cursor_tracker_electron.mm

@@ -2,7 +2,22 @@
 #import <CoreGraphics/CoreGraphics.h>
 #import <AppKit/AppKit.h>
 #import "../logging.h"
-#import "../text_input_ax_snapshot.h"
+
+static NSCursor *CursorFactoryNamed(NSString *name) {
+    if (!name || [name length] == 0) return nil;
+    SEL sel = NSSelectorFromString(name);
+    if (!sel || ![NSCursor respondsToSelector:sel]) return nil;
+    IMP imp = [NSCursor methodForSelector:sel];
+    if (!imp) return nil;
+    typedef NSCursor *(*CursorFactoryFunc)(id, SEL);
+    CursorFactoryFunc fn = (CursorFactoryFunc)imp;
+    return fn([NSCursor class], sel);
+}
+
+static BOOL CursorEqualsFactoryNamed(NSCursor *cursor, NSString *factoryName) {
+    NSCursor *ref = CursorFactoryNamed(factoryName);
+    return ref != nil && cursor == ref;
+}
 
 // Thread-safe cursor tracking for Electron
 static dispatch_queue_t g_cursorQueue = nil;
@@ -24,18 +39,34 @@ static NSString* MapCursorToType(NSCursor *cursor) {
     if (cursor == [NSCursor pointingHandCursor]) return @"pointer";
     if ([NSCursor respondsToSelector:@selector(resizeLeftRightCursor)]) {
         if (cursor == [NSCursor resizeLeftRightCursor] ||
-            [NSCursor instancesRespondToSelector:@selector(resizeLeftCursor)] && (cursor == [NSCursor resizeLeftCursor]) ||
-            [NSCursor instancesRespondToSelector:@selector(resizeRightCursor)] && (cursor == [NSCursor resizeRightCursor])) {
+            ([NSCursor respondsToSelector:@selector(resizeLeftCursor)] && cursor == [NSCursor resizeLeftCursor]) ||
+            ([NSCursor respondsToSelector:@selector(resizeRightCursor)] && cursor == [NSCursor resizeRightCursor])) {
             return @"col-resize";
         }
     }
     if ([NSCursor respondsToSelector:@selector(resizeUpDownCursor)]) {
         if (cursor == [NSCursor resizeUpDownCursor] ||
-            [NSCursor instancesRespondToSelector:@selector(resizeUpCursor)] && (cursor == [NSCursor resizeUpCursor]) ||
-            [NSCursor instancesRespondToSelector:@selector(resizeDownCursor)] && (cursor == [NSCursor resizeDownCursor])) {
+            ([NSCursor respondsToSelector:@selector(resizeUpCursor)] && cursor == [NSCursor resizeUpCursor]) ||
+            ([NSCursor respondsToSelector:@selector(resizeDownCursor)] && cursor == [NSCursor resizeDownCursor])) {
             return @"ns-resize";
         }
     }
+    if (CursorEqualsFactoryNamed(cursor, @"resizeNorthWestSouthEastCursor")) {
+        return @"nwse-resize";
+    }
+    if (CursorEqualsFactoryNamed(cursor, @"resizeNorthEastSouthWestCursor")) {
+        return @"nesw-resize";
+    }
+    if (@available(macOS 15.0, *)) {
+        if ([NSCursor respondsToSelector:@selector(columnResizeCursor)] &&
+            cursor == [NSCursor columnResizeCursor]) {
+            return @"col-resize";
+        }
+        if ([NSCursor respondsToSelector:@selector(rowResizeCursor)] &&
+            cursor == [NSCursor rowResizeCursor]) {
+            return @"row-resize";
+        }
+    }
     if ([NSCursor respondsToSelector:@selector(openHandCursor)] && cursor == [NSCursor openHandCursor]) return @"grab";
     if ([NSCursor respondsToSelector:@selector(closedHandCursor)] && cursor == [NSCursor closedHandCursor]) return @"grabbing";
     if ([NSCursor respondsToSelector:@selector(crosshairCursor)] && cursor == [NSCursor crosshairCursor]) return @"crosshair";
@@ -93,45 +124,12 @@ Napi::Value GetCursorPositionElectronSafe(const Napi::CallbackInfo& info) {
     }
 }
 
-static Napi::Value DictToNapiTextInputSnapshotElectron(Napi::Env env, NSDictionary *snap) {
-    Napi::Object o = Napi::Object::New(env);
-    NSNumber *cx = snap[@"caretX"];
-    NSNumber *cy = snap[@"caretY"];
-    o.Set("caretX", Napi::Number::New(env, cx ? [cx doubleValue] : 0));
-    o.Set("caretY", Napi::Number::New(env, cy ? [cy doubleValue] : 0));
-    NSDictionary *frame = snap[@"inputFrame"];
-    Napi::Object fo = Napi::Object::New(env);
-    if ([frame isKindOfClass:[NSDictionary class]]) {
-        fo.Set("x", Napi::Number::New(env, [frame[@"x"] doubleValue]));
-        fo.Set("y", Napi::Number::New(env, [frame[@"y"] doubleValue]));
-        fo.Set("width", Napi::Number::New(env, [frame[@"width"] doubleValue]));
-        fo.Set("height", Napi::Number::New(env, [frame[@"height"] doubleValue]));
-    }
-    o.Set("inputFrame", fo);
-    return o;
-}
-
-Napi::Value GetTextInputSnapshotElectronSafe(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    @try {
-        NSDictionary *snap = MRTextInputSnapshotDictionary();
-        if (!snap) {
-            return env.Null();
-        }
-        return DictToNapiTextInputSnapshotElectron(env, snap);
-    } @catch (NSException *e) {
-        NSLog(@"❌ getTextInputSnapshot: %@", e.reason);
-        return env.Null();
-    }
-}
-
 // Initialize cursor tracker module
 Napi::Object InitCursorTrackerElectron(Napi::Env env, Napi::Object exports) {
     @try {
         initializeCursorQueue();
         
         exports.Set("getCursorPosition", Napi::Function::New(env, GetCursorPositionElectronSafe));
-        exports.Set("getTextInputSnapshot", Napi::Function::New(env, GetTextInputSnapshotElectronSafe));
         
         MRLog(@"✅ Electron-safe cursor tracker initialized");
         return exports;

package/src/electron_safe/window_selector_electron.mm

@@ -13,9 +13,12 @@ static void initializeWindowQueue() {
 }
 
 static BOOL ShouldAllowElectronWindows(void) {
-    NSString *flag = [[[NSProcessInfo processInfo] environment] objectForKey:@"CREAVIT_ALLOW_ELECTRON_WINDOWS"];
-    if (!flag) return NO;
+    // NSProcessInfo.environment snapshot'lanır ve runtime'da process.env değişikliklerini yansıtmaz.
+    // getenv() libc üzerinden her seferinde güncel değeri okur — menüden toggle'lanabilsin diye.
+    const char *raw = getenv("CREAVIT_ALLOW_ELECTRON_WINDOWS");
+    if (!raw) return NO;
 
+    NSString *flag = [NSString stringWithUTF8String:raw];
     NSString *normalized = [[flag lowercaseString] stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
     return [normalized isEqualToString:@"1"] ||
            [normalized isEqualToString:@"true"] ||

package/src/screen_capture_kit.mm

@@ -342,23 +342,17 @@ static void FinishWriter(AVAssetWriter *writer, AVAssetWriterInput *input) {
     if (!writer) {
         return;
     }
-
-    // markAsFinished sadece AVAssetWriterStatusWriting (1) durumunda çağrılabilir
-    // Status 0 (Unknown) veya diğer durumlarda crash eder
-    if (input && writer.status == AVAssetWriterStatusWriting) {
+    
+    if (input) {
         [input markAsFinished];
     }
-
-    if (writer.status == AVAssetWriterStatusWriting) {
-        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
-        [writer finishWritingWithCompletionHandler:^{
-            dispatch_semaphore_signal(semaphore);
-        }];
-        dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC));
-        dispatch_semaphore_wait(semaphore, timeout);
-    } else if (writer.status == AVAssetWriterStatusFailed) {
-        NSLog(@"⚠️ Writer already failed: %@", writer.error);
-    }
+    
+    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+    [writer finishWritingWithCompletionHandler:^{
+        dispatch_semaphore_signal(semaphore);
+    }];
+    dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC));
+    dispatch_semaphore_wait(semaphore, timeout);
 }
 
 static void CleanupWriters(void) {
@@ -379,10 +373,10 @@ static void CleanupWriters(void) {
     }
     
     if (g_audioWriter) {
-        if (g_systemAudioInput && g_audioWriter.status == AVAssetWriterStatusWriting) {
+        if (g_systemAudioInput) {
             [g_systemAudioInput markAsFinished];
         }
-        if (g_microphoneAudioInput && g_audioWriter.status == AVAssetWriterStatusWriting) {
+        if (g_microphoneAudioInput) {
             [g_microphoneAudioInput markAsFinished];
         }
         FinishWriter(g_audioWriter, nil);

package/src/window_selector.mm

@@ -57,9 +57,12 @@ static NSTimer *g_screenTrackingTimer = nil;
 static NSInteger g_currentActiveScreenIndex = -1;
 
 static bool shouldAllowElectronWindows() {
-    NSString *flag = [[[NSProcessInfo processInfo] environment] objectForKey:@"CREAVIT_ALLOW_ELECTRON_WINDOWS"];
-    if (!flag) return false;
+    // NSProcessInfo.environment snapshot'lanır ve runtime değişikliklerini yansıtmaz.
+    // getenv() ile process.env güncellemelerini her seferinde okuyoruz.
+    const char *raw = getenv("CREAVIT_ALLOW_ELECTRON_WINDOWS");
+    if (!raw) return false;
 
+    NSString *flag = [NSString stringWithUTF8String:raw];
     NSString *normalized = [[flag lowercaseString] stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
     return [normalized isEqualToString:@"1"] ||
            [normalized isEqualToString:@"true"] ||

package/lib/cursorCapture/displayInfo.js

@@ -1,110 +0,0 @@
-"use strict";
-
-async function resolveCursorDisplayInfo(recorder, options) {
-	if (options.videoRelative && options.displayInfo) {
-		let videoOffsetX = 0;
-		let videoOffsetY = 0;
-		let videoWidth =
-			options.displayInfo.width || options.displayInfo.logicalWidth;
-		let videoHeight =
-			options.displayInfo.height || options.displayInfo.logicalHeight;
-
-		if (options.recordingType === "window" && options.windowId) {
-			if (options.captureArea) {
-				videoOffsetX = options.captureArea.x;
-				videoOffsetY = options.captureArea.y;
-				videoWidth = options.captureArea.width;
-				videoHeight = options.captureArea.height;
-			}
-		} else if (options.recordingType === "area" && options.captureArea) {
-			videoOffsetX = options.captureArea.x;
-			videoOffsetY = options.captureArea.y;
-			videoWidth = options.captureArea.width;
-			videoHeight = options.captureArea.height;
-		}
-
-		recorder.cursorDisplayInfo = {
-			displayId: options.displayInfo.displayId || options.displayInfo.id,
-			displayX: options.displayInfo.x || 0,
-			displayY: options.displayInfo.y || 0,
-			displayWidth:
-				options.displayInfo.width || options.displayInfo.logicalWidth,
-			displayHeight:
-				options.displayInfo.height || options.displayInfo.logicalHeight,
-			videoOffsetX,
-			videoOffsetY,
-			videoWidth,
-			videoHeight,
-			videoRelative: true,
-			recordingType: options.recordingType || "display",
-			captureArea: options.captureArea,
-			windowId: options.windowId,
-			multiWindowBounds: options.multiWindowBounds || null,
-		};
-		return;
-	}
-
-	if (recorder.recordingDisplayInfo) {
-		recorder.cursorDisplayInfo = {
-			...recorder.recordingDisplayInfo,
-			displayX: recorder.recordingDisplayInfo.x || 0,
-			displayY: recorder.recordingDisplayInfo.y || 0,
-			displayWidth:
-				recorder.recordingDisplayInfo.width ||
-				recorder.recordingDisplayInfo.logicalWidth,
-			displayHeight:
-				recorder.recordingDisplayInfo.height ||
-				recorder.recordingDisplayInfo.logicalHeight,
-			videoOffsetX: 0,
-			videoOffsetY: 0,
-			videoWidth:
-				recorder.recordingDisplayInfo.width ||
-				recorder.recordingDisplayInfo.logicalWidth,
-			videoHeight:
-				recorder.recordingDisplayInfo.height ||
-				recorder.recordingDisplayInfo.logicalHeight,
-			videoRelative: true,
-			recordingType: options.recordingType || "display",
-			multiWindowBounds: options.multiWindowBounds || null,
-		};
-		return;
-	}
-
-	try {
-		const displays = await recorder.getDisplays();
-		const mainDisplay =
-			displays.find((d) => d.isPrimary) || displays[0];
-		if (mainDisplay) {
-			let w = mainDisplay.width;
-			let h = mainDisplay.height;
-			const res = mainDisplay.resolution;
-			if ((w == null || h == null) && res) {
-				const parts = String(res).split("x");
-				if (w == null) {
-					w = parseInt(parts[0], 10);
-				}
-				if (h == null) {
-					h = parseInt(parts[1], 10);
-				}
-			}
-			if (!Number.isFinite(w) || w <= 0) {
-				w = 1920;
-			}
-			if (!Number.isFinite(h) || h <= 0) {
-				h = 1080;
-			}
-			recorder.cursorDisplayInfo = {
-				displayId: mainDisplay.id,
-				x: mainDisplay.x,
-				y: mainDisplay.y,
-				width: w,
-				height: h,
-				multiWindowBounds: options.multiWindowBounds || null,
-			};
-		}
-	} catch {
-		recorder.cursorDisplayInfo = null;
-	}
-}
-
-module.exports = { resolveCursorDisplayInfo };