node-mac-recorder 2.21.8 → 2.21.10

package/.claude/settings.local.json

@@ -12,7 +12,8 @@
       "Bash(MAC_RECORDER_DEBUG=1 timeout 5 node:*)",
       "Read(//private/tmp/**)",
       "Bash(ffprobe:*)",
-      "Bash(MAC_RECORDER_DEBUG=1 timeout 8 node:*)"
+      "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.8",
+	"version": "2.21.10",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [

package/src/avfoundation_recorder.mm

@@ -26,23 +26,24 @@ 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];
@@ -210,12 +211,22 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         if (includeMicrophone || includeSystemAudio) {
             MRLog(@"🎤 Starting audio capture (mic=%d, system=%d)", includeMicrophone, includeSystemAudio);
 
-            // Generate audio output path
-            NSString *videoDir = [outputPathStr stringByDeletingLastPathComponent];
-            NSString *audioFilename = [NSString stringWithFormat:@"avf_audio_%ld.mov", (long)[[NSDate date] timeIntervalSince1970]];
-            g_avAudioOutputPath = [videoDir stringByAppendingPathComponent:audioFilename];
+            // 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);
+            }
 
-            MRLog(@"🎤 Audio output: %@", 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();
@@ -225,7 +236,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                 const char* outputPathCStr = [g_avAudioOutputPath UTF8String];
 
                 if (startNativeAudioRecording(g_avAudioRecorder, deviceIdCStr, outputPathCStr)) {
-                    MRLog(@"✅ Audio recording started");
+                    MRLog(@"✅ Audio recording started to: %@", g_avAudioOutputPath);
                 } else {
                     NSLog(@"❌ Failed to start audio recording");
                     destroyNativeAudioRecorder(g_avAudioRecorder);
@@ -452,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>();
@@ -349,9 +351,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         BOOL forceAVFoundation = YES;
 
         MRLog(@"🔧 CRITICAL: ScreenCaptureKit disabled globally (segfault issue)");
-        MRLog(@"   Using AVFoundation for stability");
-        MRLog(@"   ⚠️  WARNING: Audio capture not available in AVFoundation mode");
-        MRLog(@"   Audio files will be created but will be empty");
+        MRLog(@"   Using AVFoundation for stability with integrated audio capture");
 
         if (isElectron) {
             MRLog(@"⚡ Electron environment detected - using stable AVFoundation");
@@ -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");
@@ -500,16 +501,9 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                     return Napi::Boolean::New(env, false);
                 }
 
-                if (!startAudioIfRequested(captureAnyAudio, audioOutputPath, preferredAudioDeviceId)) {
-                    MRLog(@"❌ Audio start failed - stopping AVFoundation session");
-                    if (captureCamera) {
-                        stopCameraRecording();
-                    }
-                    stopAVFoundationRecording();
-                    g_isRecording = false;
-                    return Napi::Boolean::New(env, false);
-                }
-                
+                // NOTE: Audio is handled internally by AVFoundation, no need for standalone audio
+                // AVFoundation integrates audio recording directly
+
                 g_isRecording = true;
                 return Napi::Boolean::New(env, true);
             } else {
@@ -554,6 +548,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 +862,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();
         }