node-mac-recorder 2.21.7 → 2.21.9

package/.claude/settings.local.json

@@ -11,7 +11,9 @@
       "Read(//private/tmp/test-recording/**)",
       "Bash(MAC_RECORDER_DEBUG=1 timeout 5 node:*)",
       "Read(//private/tmp/**)",
-      "Bash(ffprobe:*)"
+      "Bash(ffprobe:*)",
+      "Bash(MAC_RECORDER_DEBUG=1 timeout 8 node:*)",
+      "Bash(cat:*)"
     ],
     "deny": [],
     "ask": []

package/index.js

@@ -152,21 +152,40 @@ class MacRecorder extends EventEmitter {
 	 * Kayıt seçeneklerini ayarlar
 	 */
 	setOptions(options = {}) {
-		this.options = {
-			includeMicrophone: options.includeMicrophone === true, // Explicit true required, default false
-			includeSystemAudio: options.includeSystemAudio === true, // Explicit true required, default false  
-			captureCursor: options.captureCursor || false,
-			displayId: options.displayId || null, // null = ana ekran
-			windowId: options.windowId || null, // null = tam ekran
-			audioDeviceId: options.audioDeviceId || null, // null = default device
-			systemAudioDeviceId: options.systemAudioDeviceId || null, // null = auto-detect system audio device
-			captureArea: options.captureArea || null,
-			captureCamera: options.captureCamera === true,
-			cameraDeviceId:
+		// Merge options instead of replacing to preserve previously set values
+		if (options.includeMicrophone !== undefined) {
+			this.options.includeMicrophone = options.includeMicrophone === true;
+		}
+		if (options.includeSystemAudio !== undefined) {
+			this.options.includeSystemAudio = options.includeSystemAudio === true;
+		}
+		if (options.captureCursor !== undefined) {
+			this.options.captureCursor = options.captureCursor || false;
+		}
+		if (options.displayId !== undefined) {
+			this.options.displayId = options.displayId || null;
+		}
+		if (options.windowId !== undefined) {
+			this.options.windowId = options.windowId || null;
+		}
+		if (options.audioDeviceId !== undefined) {
+			this.options.audioDeviceId = options.audioDeviceId || null;
+		}
+		if (options.systemAudioDeviceId !== undefined) {
+			this.options.systemAudioDeviceId = options.systemAudioDeviceId || null;
+		}
+		if (options.captureArea !== undefined) {
+			this.options.captureArea = options.captureArea || null;
+		}
+		if (options.captureCamera !== undefined) {
+			this.options.captureCamera = options.captureCamera === true;
+		}
+		if (options.cameraDeviceId !== undefined) {
+			this.options.cameraDeviceId =
 				typeof options.cameraDeviceId === "string" && options.cameraDeviceId.length > 0
 					? options.cameraDeviceId
-					: null,
-		};
+					: null;
+		}
 	}
 
 	/**

package/package.json

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

package/src/audio_recorder.mm

@@ -369,4 +369,37 @@ NSString *currentStandaloneAudioRecordingPath() {
     return g_audioRecorder.outputPath;
 }
 
+// C API for AVFoundation integration
+void* createNativeAudioRecorder() {
+    return (__bridge_retained void*)[[NativeAudioRecorder alloc] init];
+}
+
+bool startNativeAudioRecording(void* recorder, const char* deviceId, const char* outputPath) {
+    if (!recorder || !outputPath) {
+        return false;
+    }
+
+    NativeAudioRecorder* audioRecorder = (__bridge NativeAudioRecorder*)recorder;
+    NSString* deviceIdStr = deviceId ? [NSString stringWithUTF8String:deviceId] : nil;
+    NSString* outputPathStr = [NSString stringWithUTF8String:outputPath];
+
+    NSError* error = nil;
+    return [audioRecorder startRecordingWithDeviceId:deviceIdStr outputPath:outputPathStr error:&error];
+}
+
+bool stopNativeAudioRecording(void* recorder) {
+    if (!recorder) {
+        return false;
+    }
+
+    NativeAudioRecorder* audioRecorder = (__bridge NativeAudioRecorder*)recorder;
+    return [audioRecorder stopRecording];
+}
+
+void destroyNativeAudioRecorder(void* recorder) {
+    if (recorder) {
+        CFRelease(recorder);
+    }
+}
+
 }

package/src/avfoundation_recorder.mm

@@ -7,6 +7,12 @@
 #include <string>
 #import "logging.h"
 
+// Import audio recorder
+extern "C" void* createNativeAudioRecorder(void);
+extern "C" bool startNativeAudioRecording(void* recorder, const char* deviceId, const char* outputPath);
+extern "C" bool stopNativeAudioRecording(void* recorder);
+extern "C" void destroyNativeAudioRecorder(void* recorder);
+
 static AVAssetWriter *g_avWriter = nil;
 static AVAssetWriterInput *g_avVideoInput = nil;
 static AVAssetWriterInputPixelBufferAdaptor *g_avPixelBufferAdaptor = nil;
@@ -16,25 +22,28 @@ static CGRect g_avCaptureRect = CGRectZero;
 static bool g_avIsRecording = false;
 static int64_t g_avFrameNumber = 0;
 static CMTime g_avStartTime;
+static void* g_avAudioRecorder = nil;
+static NSString* g_avAudioOutputPath = nil;
 
 // AVFoundation screen recording implementation
-extern "C" bool startAVFoundationRecording(const std::string& outputPath, 
+extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                                            CGDirectDisplayID displayID,
                                            uint32_t windowID,
                                            CGRect captureRect,
                                            bool captureCursor,
-                                           bool includeMicrophone, 
+                                           bool includeMicrophone,
                                            bool includeSystemAudio,
-                                           NSString* audioDeviceId) {
+                                           NSString* audioDeviceId,
+                                           NSString* audioOutputPath) {
     
     if (g_avIsRecording) {
         NSLog(@"❌ AVFoundation recording already in progress");
         return false;
     }
-    
+
     @try {
         MRLog(@"🎬 AVFoundation: Starting recording initialization");
-        
+
         // Create output URL
         NSString *outputPathStr = [NSString stringWithUTF8String:outputPath.c_str()];
         NSURL *outputURL = [NSURL fileURLWithPath:outputPathStr];
@@ -197,7 +206,48 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         }
         
         g_avFrameNumber = 0;
-        
+
+        // Start audio recording if requested
+        if (includeMicrophone || includeSystemAudio) {
+            MRLog(@"🎤 Starting audio capture (mic=%d, system=%d)", includeMicrophone, includeSystemAudio);
+
+            // Use provided audio output path or generate one
+            if (audioOutputPath && [audioOutputPath length] > 0) {
+                g_avAudioOutputPath = audioOutputPath;
+                MRLog(@"🎤 Using provided audio path: %@", g_avAudioOutputPath);
+            } else {
+                NSString *videoDir = [outputPathStr stringByDeletingLastPathComponent];
+                NSString *audioFilename = [NSString stringWithFormat:@"avf_audio_%ld.mov", (long)[[NSDate date] timeIntervalSince1970]];
+                g_avAudioOutputPath = [videoDir stringByAppendingPathComponent:audioFilename];
+                MRLog(@"🎤 Generated audio path: %@", g_avAudioOutputPath);
+            }
+
+            // Ensure .mov extension
+            if (![g_avAudioOutputPath.pathExtension.lowercaseString isEqualToString:@"mov"]) {
+                g_avAudioOutputPath = [[g_avAudioOutputPath stringByDeletingPathExtension] stringByAppendingPathExtension:@"mov"];
+                MRLog(@"🔧 Fixed audio extension to .mov: %@", g_avAudioOutputPath);
+            }
+
+            // Create audio recorder
+            g_avAudioRecorder = createNativeAudioRecorder();
+
+            if (g_avAudioRecorder) {
+                const char* deviceIdCStr = audioDeviceId ? [audioDeviceId UTF8String] : NULL;
+                const char* outputPathCStr = [g_avAudioOutputPath UTF8String];
+
+                if (startNativeAudioRecording(g_avAudioRecorder, deviceIdCStr, outputPathCStr)) {
+                    MRLog(@"✅ Audio recording started to: %@", g_avAudioOutputPath);
+                } else {
+                    NSLog(@"❌ Failed to start audio recording");
+                    destroyNativeAudioRecorder(g_avAudioRecorder);
+                    g_avAudioRecorder = nil;
+                    g_avAudioOutputPath = nil;
+                }
+            } else {
+                NSLog(@"❌ Failed to create audio recorder");
+            }
+        }
+
         // Start capture timer (10 FPS for Electron compatibility)
         dispatch_queue_t captureQueue = dispatch_queue_create("AVFoundationCaptureQueue", DISPATCH_QUEUE_SERIAL);
         g_avTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, captureQueue);
@@ -348,9 +398,18 @@ extern "C" bool stopAVFoundationRecording() {
     if (!g_avIsRecording) {
         return true;
     }
-    
+
     g_avIsRecording = false;
-    
+
+    // Stop audio recording if active
+    if (g_avAudioRecorder) {
+        MRLog(@"🛑 Stopping audio recording");
+        stopNativeAudioRecording(g_avAudioRecorder);
+        destroyNativeAudioRecorder(g_avAudioRecorder);
+        g_avAudioRecorder = nil;
+        MRLog(@"✅ Audio recording stopped");
+    }
+
     @try {
         // Stop timer with Electron-safe cleanup
         if (g_avTimer) {
@@ -404,3 +463,7 @@ extern "C" bool stopAVFoundationRecording() {
 extern "C" bool isAVFoundationRecording() {
     return g_avIsRecording;
 }
+
+extern "C" NSString* getAVFoundationAudioPath() {
+    return g_avAudioOutputPath;
+}

package/src/mac_recorder.mm

@@ -11,16 +11,18 @@
 
 // AVFoundation fallback declarations
 extern "C" {
-    bool startAVFoundationRecording(const std::string& outputPath, 
+    bool startAVFoundationRecording(const std::string& outputPath,
                                    CGDirectDisplayID displayID,
                                    uint32_t windowID,
                                    CGRect captureRect,
                                    bool captureCursor,
-                                   bool includeMicrophone, 
+                                   bool includeMicrophone,
                                    bool includeSystemAudio,
-                                   NSString* audioDeviceId);
+                                   NSString* audioDeviceId,
+                                   NSString* audioOutputPath);
     bool stopAVFoundationRecording();
     bool isAVFoundationRecording();
+    NSString* getAVFoundationAudioPath();
 
     NSArray<NSDictionary *> *listCameraDevices();
     bool startCameraRecording(NSString *outputPath, NSString *deviceId, NSError **error);
@@ -196,7 +198,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     
     if (info.Length() > 1 && info[1].IsObject()) {
         Napi::Object options = info[1].As<Napi::Object>();
-        
+
         // Capture area
         if (options.Has("captureArea") && options.Get("captureArea").IsObject()) {
             Napi::Object rectObj = options.Get("captureArea").As<Napi::Object>();
@@ -217,15 +219,15 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         
         // Microphone
         if (options.Has("includeMicrophone")) {
-            includeMicrophone = options.Get("includeMicrophone").As<Napi::Boolean>();
+            includeMicrophone = options.Get("includeMicrophone").As<Napi::Boolean>().Value();
         }
-        
+
         // Audio device ID
         if (options.Has("audioDeviceId") && !options.Get("audioDeviceId").IsNull()) {
             std::string deviceId = options.Get("audioDeviceId").As<Napi::String>().Utf8Value();
             audioDeviceId = [NSString stringWithUTF8String:deviceId.c_str()];
         }
-        
+
         // System audio
         if (options.Has("includeSystemAudio")) {
             includeSystemAudio = options.Get("includeSystemAudio").As<Napi::Boolean>();
@@ -343,18 +345,16 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             MRLog(@"   Reason: ScreenCaptureKit has thread safety issues in Electron (SIGTRAP crashes)");
         }
 
-        // Force AVFoundation for debugging/testing OR Electron
-        BOOL forceAVFoundation = (getenv("FORCE_AVFOUNDATION") != NULL) || isElectron;
-        if (getenv("FORCE_AVFOUNDATION") != NULL) {
-            MRLog(@"🔧 FORCE_AVFOUNDATION environment variable detected");
-        }
+        // CRITICAL FIX: ScreenCaptureKit causes segmentation faults
+        // Forcing AVFoundation for ALL environments until issue is resolved
+        // TODO: Implement audio capture in AVFoundation
+        BOOL forceAVFoundation = YES;
+
+        MRLog(@"🔧 CRITICAL: ScreenCaptureKit disabled globally (segfault issue)");
+        MRLog(@"   Using AVFoundation for stability with integrated audio capture");
 
-        // CRITICAL: ScreenCaptureKit causes segmentation faults in both Node.js and Electron
-        // FORCE AVFoundation for ALL environments until Apple fixes stability issues
-        forceAVFoundation = YES;
-        if (forceAVFoundation) {
-            MRLog(@"🔧 CRITICAL: ScreenCaptureKit disabled due to segmentation faults");
-            MRLog(@"   Using AVFoundation for stability in ALL environments");
+        if (isElectron) {
+            MRLog(@"⚡ Electron environment detected - using stable AVFoundation");
         }
 
         // Electron-first priority: ALWAYS use AVFoundation in Electron for stability
@@ -474,20 +474,21 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         
         // AVFoundation recording (either fallback from ScreenCaptureKit or direct)
         MRLog(@"🎥 Starting AVFoundation recording...");
-        
+
         @try {
             // Import AVFoundation recording functions (if available)
-            extern bool startAVFoundationRecording(const std::string& outputPath, 
+            extern bool startAVFoundationRecording(const std::string& outputPath,
                                                    CGDirectDisplayID displayID,
                                                    uint32_t windowID,
                                                    CGRect captureRect,
                                                    bool captureCursor,
-                                                   bool includeMicrophone, 
+                                                   bool includeMicrophone,
                                                    bool includeSystemAudio,
-                                                   NSString* audioDeviceId);
-            
-            bool avResult = startAVFoundationRecording(outputPath, displayID, windowID, captureRect, 
-                                                      captureCursor, includeMicrophone, includeSystemAudio, audioDeviceId);
+                                                   NSString* audioDeviceId,
+                                                   NSString* audioOutputPath);
+
+            bool avResult = startAVFoundationRecording(outputPath, displayID, windowID, captureRect,
+                                                      captureCursor, includeMicrophone, includeSystemAudio, audioDeviceId, audioOutputPath);
             
             if (avResult) {
                 MRLog(@"🎥 RECORDING METHOD: AVFoundation");
@@ -554,6 +555,7 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     // Try AVFoundation fallback (supports both Node.js and Electron)
     extern bool isAVFoundationRecording();
     extern bool stopAVFoundationRecording();
+    extern NSString* getAVFoundationAudioPath();
     
     @try {
         if (isAVFoundationRecording()) {
@@ -867,6 +869,9 @@ Napi::Value GetAudioRecordingPath(const Napi::CallbackInfo& info) {
         if (!path || [path length] == 0) {
             path = currentStandaloneAudioRecordingPath();
         }
+        if (!path || [path length] == 0) {
+            path = getAVFoundationAudioPath();
+        }
         if (!path || [path length] == 0) {
             return env.Null();
         }