node-mac-recorder 2.21.20 → 2.21.22

package/.claude/settings.local.json

@@ -5,7 +5,11 @@
       "Bash(chmod:*)",
       "Bash(node test-sync.js:*)",
       "Bash(node:*)",
-      "Bash(ALLOW_CONTINUITY_CAMERA=1 node:*)"
+      "Bash(ALLOW_CONTINUITY_CAMERA=1 node:*)",
+      "Bash(awk:*)",
+      "Bash(ffprobe:*)",
+      "Bash(sw_vers:*)",
+      "Bash(system_profiler:*)"
     ],
     "deny": [],
     "ask": []

package/index.js

@@ -103,6 +103,7 @@ class MacRecorder extends EventEmitter {
 					position: device?.position ?? "unspecified",
 					transportType: device?.transportType ?? null,
 					isConnected: device?.isConnected ?? false,
+					isDefault: device?.isDefault === true,
 					hasFlash: device?.hasFlash ?? false,
 					supportsDepth: device?.supportsDepth ?? false,
 					deviceType: device?.deviceType ?? null,

package/package.json

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

package/src/audio_recorder.mm

@@ -224,10 +224,30 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
         return YES;
     }
 
-    [self.session stopRunning];
+    // CRITICAL FIX: For external devices (especially Continuity Microphone),
+    // stopRunning can hang if device is disconnected. Use async approach.
+    MRLog(@"🛑 AudioRecorder: Stopping session (external device safe)...");
+
+    // Stop session on background thread to avoid blocking
+    AVCaptureSession *sessionToStop = self.session;
+    AVCaptureAudioDataOutput *outputToStop = self.audioOutput;
+
+    // Clear references FIRST to prevent new samples
     self.session = nil;
     self.audioOutput = nil;
 
+    // Stop session asynchronously with timeout protection
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        @autoreleasepool {
+            if ([sessionToStop isRunning]) {
+                MRLog(@"🛑 Stopping AVCaptureSession...");
+                [sessionToStop stopRunning];
+                MRLog(@"✅ AVCaptureSession stopped");
+            }
+            // Release happens automatically when block completes
+        }
+    });
+
     // CRITICAL FIX: Check if writer exists before trying to finish it
     if (self.writer) {
         // Only mark as finished if writerInput exists
@@ -243,16 +263,16 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
             dispatch_semaphore_signal(semaphore);
         }];
 
-        // Reduced timeout to 2 seconds for faster response
-        dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC));
-        dispatch_semaphore_wait(semaphore, timeout);
+        // Reduced timeout to 1 second for external devices
+        dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC));
+        long result = dispatch_semaphore_wait(semaphore, timeout);
 
-        if (!finished) {
-            MRLog(@"⚠️ AudioRecorder: Timed out waiting for writer to finish");
+        if (result != 0 || !finished) {
+            MRLog(@"⚠️ AudioRecorder: Timed out waiting for writer (external device?) - forcing cancel");
             // Force cancel if timeout
             [self.writer cancelWriting];
         } else {
-            MRLog(@"✅ AudioRecorder stopped successfully");
+            MRLog(@"✅ AudioRecorder writer finished successfully");
         }
     } else {
         MRLog(@"⚠️ AudioRecorder: No writer to finish (no audio captured)");
@@ -264,6 +284,7 @@ static dispatch_queue_t g_audioCaptureQueue = nil;
     self.startTime = kCMTimeInvalid;
     self.outputPath = nil;
 
+    MRLog(@"✅ AudioRecorder stopped (safe for external devices)");
     return YES;
 }
 
@@ -334,11 +355,37 @@ NSArray<NSDictionary *> *listAudioCaptureDevices() {
                                position:AVCaptureDevicePositionUnspecified];
 
     for (AVCaptureDevice *device in session.devices) {
+        // PRIORITY FIX: MacBook built-in devices should be default, not external devices
+        // Check if this is a built-in device (MacBook's own microphone)
+        NSString *deviceName = device.localizedName ?: @"";
+        BOOL isBuiltIn = NO;
+
+        // Built-in detection: Check for "MacBook", "iMac", "Mac Studio", "Mac mini", "Mac Pro" in name
+        if ([deviceName rangeOfString:@"MacBook" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iMac" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Mac Studio" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Mac mini" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Mac Pro" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = YES;
+        }
+
+        // Also check for generic "Built-in" in name
+        if ([deviceName rangeOfString:@"Built-in" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = YES;
+        }
+
+        // External devices (Continuity, USB, etc.) should NOT be default
+        if ([deviceName rangeOfString:@"Continuity" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iPhone" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iPad" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = NO;
+        }
+
         NSDictionary *info = @{
             @"id": device.uniqueID ?: @"",
-            @"name": device.localizedName ?: @"Unknown Audio Device",
+            @"name": deviceName,
             @"manufacturer": device.manufacturer ?: @"",
-            @"isDefault": @(device.connected),
+            @"isDefault": @(isBuiltIn), // Only built-in devices are default
             @"transportType": @(device.transportType)
         };
         [devicesInfo addObject:info];

package/src/avfoundation_recorder.mm

@@ -120,16 +120,30 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             codecKey = AVVideoCodecH264;
         }
         
+        // QUALITY FIX: ULTRA HIGH quality screen recording
+        // ProMotion displays may capture at 10 FPS - use very high bitrate for perfect quality
+        NSInteger bitrate = (NSInteger)(recordingSize.width * recordingSize.height * 30);
+        bitrate = MAX(bitrate, 30 * 1000 * 1000);  // Minimum 30 Mbps
+        bitrate = MIN(bitrate, 120 * 1000 * 1000); // Maximum 120 Mbps
+
+        NSLog(@"🎬 ULTRA QUALITY AVFoundation: %dx%d, bitrate=%.2fMbps",
+              (int)recordingSize.width, (int)recordingSize.height, bitrate / (1000.0 * 1000.0));
+
         NSDictionary *videoSettings = @{
             AVVideoCodecKey: codecKey,
             AVVideoWidthKey: @((int)recordingSize.width),
             AVVideoHeightKey: @((int)recordingSize.height),
             AVVideoCompressionPropertiesKey: @{
-                AVVideoAverageBitRateKey: @(recordingSize.width * recordingSize.height * 8),
-                AVVideoMaxKeyFrameIntervalKey: @30
+                AVVideoAverageBitRateKey: @(bitrate),
+                AVVideoMaxKeyFrameIntervalKey: @30,
+                AVVideoAllowFrameReorderingKey: @YES,
+                AVVideoExpectedSourceFrameRateKey: @60,
+                AVVideoQualityKey: @(0.95),  // 0.0-1.0, higher is better
+                AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
+                AVVideoH264EntropyModeKey: AVVideoH264EntropyModeCABAC
             }
         };
-        
+
         NSLog(@"🔧 Using codec: %@", codecKey);
         
         // Create video input

package/src/camera_recorder.mm

@@ -189,18 +189,58 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
                 position = @"unspecified";
                 break;
         }
-        
+
+        // PRIORITY FIX: MacBook built-in cameras should be default, not external cameras
+        // Check if this is a built-in camera (MacBook's own camera)
+        NSString *deviceName = device.localizedName ?: @"";
+        NSString *deviceType = device.deviceType ?: @"";
+        BOOL isBuiltIn = NO;
+
+        // Built-in detection: Check for common built-in camera names
+        if ([deviceName rangeOfString:@"FaceTime" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iSight" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Built-in" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = YES;
+        }
+
+        // Check device type for built-in wide angle camera
+        if (@available(macOS 10.15, *)) {
+            if ([deviceType isEqualToString:AVCaptureDeviceTypeBuiltInWideAngleCamera]) {
+                isBuiltIn = YES;
+            }
+        }
+
+        // External devices (Continuity Camera, iPhone, iPad, USB) should NOT be default
+        if (continuityCamera ||
+            [deviceName rangeOfString:@"iPhone" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"iPad" options:NSCaseInsensitiveSearch].location != NSNotFound ||
+            [deviceName rangeOfString:@"Continuity" options:NSCaseInsensitiveSearch].location != NSNotFound) {
+            isBuiltIn = NO;
+        }
+
+        // External device types should not be default
+        if (@available(macOS 14.0, *)) {
+            if ([deviceType isEqualToString:AVCaptureDeviceTypeExternal] ||
+                [deviceType isEqualToString:AVCaptureDeviceTypeContinuityCamera]) {
+                isBuiltIn = NO;
+            }
+        }
+        if ([deviceType isEqualToString:AVCaptureDeviceTypeExternalUnknown]) {
+            isBuiltIn = NO;
+        }
+
         NSDictionary *deviceInfo = @{
             @"id": device.uniqueID ?: @"",
-            @"name": device.localizedName ?: @"Unknown Camera",
+            @"name": deviceName,
             @"model": device.modelID ?: @"",
             @"manufacturer": device.manufacturer ?: @"",
             @"position": position ?: @"unspecified",
             @"transportType": @(device.transportType),
             @"isConnected": @(device.isConnected),
+            @"isDefault": @(isBuiltIn), // Only built-in cameras are default
             @"hasFlash": @(device.hasFlash),
             @"supportsDepth": @NO,
-            @"deviceType": device.deviceType ?: @"",
+            @"deviceType": deviceType,
             @"requiresContinuityCameraPermission": @(continuityCamera),
             @"maxResolution": @{
                 @"width": @(bestDimensions.width),
@@ -678,17 +718,33 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         return YES;
     }
 
+    // CRITICAL FIX: For external cameras (especially Continuity Camera/iPhone),
+    // stopRunning can hang if device is disconnected. Use async approach.
+    MRLog(@"🛑 CameraRecorder: Stopping session (external device safe)...");
+
     self.isShuttingDown = YES;
     self.isRecording = NO;
 
-    @try {
-        [self.session stopRunning];
-    } @catch (NSException *exception) {
-        MRLog(@"⚠️ CameraRecorder: Exception while stopping session: %@", exception.reason);
-    }
-
+    // Stop delegate FIRST to prevent new frames
     [self.videoOutput setSampleBufferDelegate:nil queue:nil];
 
+    // Stop session on background thread to avoid blocking
+    AVCaptureSession *sessionToStop = self.session;
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        @autoreleasepool {
+            @try {
+                if ([sessionToStop isRunning]) {
+                    MRLog(@"🛑 Stopping AVCaptureSession (camera)...");
+                    [sessionToStop stopRunning];
+                    MRLog(@"✅ AVCaptureSession stopped (camera)");
+                }
+            } @catch (NSException *exception) {
+                MRLog(@"⚠️ CameraRecorder: Exception while stopping session: %@", exception.reason);
+            }
+            // Release happens automatically when block completes
+        }
+    });
+
     // CRITICAL FIX: Check if assetWriter exists before trying to finish it
     // If no frames were captured, assetWriter will be nil
     if (!self.assetWriter) {
@@ -709,12 +765,12 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         dispatch_semaphore_signal(semaphore);
     }];
 
-    // Reduced timeout to 2 seconds for faster response
-    dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC));
-    dispatch_semaphore_wait(semaphore, timeout);
+    // Reduced timeout to 1 second for external devices
+    dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC));
+    long result = dispatch_semaphore_wait(semaphore, timeout);
 
-    if (!finished) {
-        MRLog(@"⚠️ CameraRecorder: Timed out waiting for writer to finish");
+    if (result != 0 || !finished) {
+        MRLog(@"⚠️ CameraRecorder: Timed out waiting for writer (external device?) - forcing cancel");
         // Force cancel if timeout
         [self.assetWriter cancelWriting];
     }
@@ -723,10 +779,11 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     if (!success) {
         MRLog(@"⚠️ CameraRecorder: Writer finished with status %ld error %@", (long)self.assetWriter.status, self.assetWriter.error);
     } else {
-        MRLog(@"✅ CameraRecorder stopped successfully");
+        MRLog(@"✅ CameraRecorder writer finished successfully");
     }
 
     [self resetState];
+    MRLog(@"✅ CameraRecorder stopped (safe for external devices)");
     return success;
 }
 

package/src/mac_recorder.mm

@@ -827,6 +827,7 @@ Napi::Value GetCameraDevices(const Napi::CallbackInfo& info) {
                 NSString *position = camera[@"position"];
                 NSNumber *transportType = camera[@"transportType"];
                 NSNumber *isConnected = camera[@"isConnected"];
+                NSNumber *isDefault = camera[@"isDefault"];
                 NSNumber *hasFlash = camera[@"hasFlash"];
                 NSNumber *supportsDepth = camera[@"supportsDepth"];
                 
@@ -861,7 +862,11 @@ Napi::Value GetCameraDevices(const Napi::CallbackInfo& info) {
                 if (isConnected && [isConnected isKindOfClass:[NSNumber class]]) {
                     cameraObj.Set("isConnected", Napi::Boolean::New(env, [isConnected boolValue]));
                 }
-                
+
+                if (isDefault && [isDefault isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("isDefault", Napi::Boolean::New(env, [isDefault boolValue]));
+                }
+
                 if (hasFlash && [hasFlash isKindOfClass:[NSNumber class]]) {
                     cameraObj.Set("hasFlash", Napi::Boolean::New(env, [hasFlash boolValue]));
                 }

package/src/screen_capture_kit.mm

@@ -33,6 +33,10 @@ static BOOL g_audioWriterStarted = NO;
 static NSInteger g_configuredSampleRate = 48000;
 static NSInteger g_configuredChannelCount = 2;
 
+// Frame rate debugging
+static NSInteger g_frameCount = 0;
+static CFAbsoluteTime g_firstFrameTime = 0;
+
 static void CleanupWriters(void);
 static AVAssetWriterInputPixelBufferAdaptor * _Nullable CurrentPixelBufferAdaptor(void) {
     if (!g_pixelBufferAdaptorRef) {
@@ -90,6 +94,10 @@ static void CleanupWriters(void) {
         }
         g_videoWriterStarted = NO;
         g_videoStartTime = kCMTimeInvalid;
+
+        // Reset frame counting
+        g_frameCount = 0;
+        g_firstFrameTime = 0;
     }
     
     if (g_audioWriter) {
@@ -217,6 +225,17 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     if (!appended) {
         NSLog(@"⚠️ Failed appending pixel buffer: %@", g_videoWriter.error);
     }
+
+    // Frame rate debugging
+    g_frameCount++;
+    if (g_firstFrameTime == 0) {
+        g_firstFrameTime = CFAbsoluteTimeGetCurrent();
+    }
+    if (g_frameCount % 60 == 0) {
+        CFAbsoluteTime elapsed = CFAbsoluteTimeGetCurrent() - g_firstFrameTime;
+        double actualFPS = g_frameCount / elapsed;
+        MRLog(@"📊 Frame stats: %ld frames in %.1fs = %.1f FPS", (long)g_frameCount, elapsed, actualFPS);
+    }
 }
 @end
 
@@ -310,11 +329,27 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         return NO;
     }
     
+    // QUALITY FIX: ULTRA HIGH quality for screen recording
+    // ProMotion displays may run at 10Hz (low power) = 10 FPS capture
+    // Solution: Use VERY HIGH bitrate so each frame is perfect quality
+    // Use 30x multiplier for ULTRA quality (was 6x - way too low!)
+    NSInteger bitrate = (NSInteger)(width * height * 30);
+    bitrate = MAX(bitrate, 30 * 1000 * 1000);  // Minimum 30 Mbps for crystal clear screen recording
+    bitrate = MIN(bitrate, 120 * 1000 * 1000); // Maximum 120 Mbps for ultra quality
+
+    MRLog(@"🎬 ULTRA QUALITY Screen encoder: %ldx%ld, bitrate=%.2fMbps",
+          (long)width, (long)height, bitrate / (1000.0 * 1000.0));
+
     NSDictionary *compressionProps = @{
-        AVVideoAverageBitRateKey: @(width * height * 6),
-        AVVideoMaxKeyFrameIntervalKey: @30
+        AVVideoAverageBitRateKey: @(bitrate),
+        AVVideoMaxKeyFrameIntervalKey: @30,
+        AVVideoAllowFrameReorderingKey: @YES,
+        AVVideoExpectedSourceFrameRateKey: @60,
+        AVVideoQualityKey: @(0.95),  // 0.0-1.0, higher is better (0.95 = excellent)
+        AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
+        AVVideoH264EntropyModeKey: AVVideoH264EntropyModeCABAC
     };
-    
+
     NSDictionary *videoSettings = @{
         AVVideoCodecKey: AVVideoCodecTypeH264,
         AVVideoWidthKey: @(width),
@@ -602,13 +637,20 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
             }
         }
         
-        // Configure stream with extracted options
+        // Configure stream with HIGH QUALITY settings
         SCStreamConfiguration *streamConfig = [[SCStreamConfiguration alloc] init];
         streamConfig.width = recordingWidth;
         streamConfig.height = recordingHeight;
-        streamConfig.minimumFrameInterval = CMTimeMake(1, 30); // 30 FPS
+        streamConfig.minimumFrameInterval = CMTimeMake(1, 60); // 60 FPS for smooth recording
         streamConfig.pixelFormat = kCVPixelFormatType_32BGRA;
         streamConfig.scalesToFit = NO;
+
+        // QUALITY FIX: Set high quality encoding parameters
+        if (@available(macOS 13.0, *)) {
+            streamConfig.queueDepth = 8; // Larger queue for smoother capture
+        }
+
+        MRLog(@"🎬 ScreenCaptureKit config: %ldx%ld @ 60fps", (long)recordingWidth, (long)recordingHeight);
         
         BOOL shouldCaptureMic = includeMicrophone ? [includeMicrophone boolValue] : NO;
         BOOL shouldCaptureSystemAudio = includeSystemAudio ? [includeSystemAudio boolValue] : NO;