node-mac-recorder 2.20.17 → 2.21.1

package/src/mac_recorder.mm

@@ -21,6 +21,21 @@ extern "C" {
                                    NSString* audioDeviceId);
     bool stopAVFoundationRecording();
     bool isAVFoundationRecording();
+
+    NSArray<NSDictionary *> *listCameraDevices();
+    bool startCameraRecording(NSString *outputPath, NSString *deviceId, NSError **error);
+    bool stopCameraRecording();
+    bool isCameraRecording();
+    NSString *currentCameraRecordingPath();
+    NSString *currentStandaloneAudioRecordingPath();
+
+    NSArray<NSDictionary *> *listAudioCaptureDevices();
+    bool startStandaloneAudioRecording(NSString *outputPath, NSString *preferredDeviceId, NSError **error);
+    bool stopStandaloneAudioRecording();
+    bool isStandaloneAudioRecording();
+    bool hasAudioPermission();
+
+    NSString *ScreenCaptureKitCurrentAudioPath(void);
 }
 
 // Cursor tracker function declarations
@@ -42,6 +57,80 @@ extern "C" void showOverlays();
 // Global state for recording (ScreenCaptureKit only)
 static MacRecorderDelegate *g_delegate = nil;
 static bool g_isRecording = false;
+static bool g_usingStandaloneAudio = false;
+
+static bool startCameraIfRequested(bool captureCamera,
+                                   NSString **cameraOutputPathRef,
+                                   NSString *cameraDeviceId,
+                                   const std::string &screenOutputPath,
+                                   int64_t sessionTimestampMs) {
+    if (!captureCamera) {
+        return true;
+    }
+    
+    NSString *resolvedOutputPath = cameraOutputPathRef ? *cameraOutputPathRef : nil;
+    if (!resolvedOutputPath || [resolvedOutputPath length] == 0) {
+        NSString *screenPath = [NSString stringWithUTF8String:screenOutputPath.c_str()];
+        NSString *directory = nil;
+        if (screenPath && [screenPath length] > 0) {
+            directory = [screenPath stringByDeletingLastPathComponent];
+        }
+        if (!directory || [directory length] == 0) {
+            directory = [[NSFileManager defaultManager] currentDirectoryPath];
+        }
+        int64_t timestampValue = sessionTimestampMs > 0 ? sessionTimestampMs
+                               : (int64_t)([[NSDate date] timeIntervalSince1970] * 1000.0);
+        NSString *fileName = [NSString stringWithFormat:@"temp_camera_%lld.webm", timestampValue];
+        resolvedOutputPath = [directory stringByAppendingPathComponent:fileName];
+        MRLog(@"📁 Auto-generated camera path: %@", resolvedOutputPath);
+    }
+    
+    NSError *cameraError = nil;
+    bool cameraStarted = startCameraRecording(resolvedOutputPath, cameraDeviceId, &cameraError);
+    if (!cameraStarted) {
+        if (cameraError) {
+            NSLog(@"❌ Failed to start camera recording: %@", cameraError.localizedDescription);
+        } else {
+            NSLog(@"❌ Failed to start camera recording: Unknown error");
+        }
+        return false;
+    }
+    NSString *actualPath = currentCameraRecordingPath();
+    if (actualPath && [actualPath length] > 0) {
+        resolvedOutputPath = actualPath;
+        if (cameraOutputPathRef) {
+            *cameraOutputPathRef = actualPath;
+        }
+    }
+    
+    MRLog(@"🎥 Camera recording started (output: %@)", resolvedOutputPath);
+    return true;
+}
+
+static bool startAudioIfRequested(bool captureAudio,
+                                  NSString *audioOutputPath,
+                                  NSString *preferredDeviceId) {
+    if (!captureAudio) {
+        return true;
+    }
+    if (!audioOutputPath || [audioOutputPath length] == 0) {
+        NSLog(@"❌ Audio recording requested but no output path provided");
+        return false;
+    }
+    NSError *audioError = nil;
+    bool started = startStandaloneAudioRecording(audioOutputPath, preferredDeviceId, &audioError);
+    if (!started) {
+        if (audioError) {
+            NSLog(@"❌ Failed to start audio recording: %@", audioError.localizedDescription);
+        } else {
+            NSLog(@"❌ Failed to start audio recording (unknown error)");
+        }
+        return false;
+    }
+    g_usingStandaloneAudio = true;
+    MRLog(@"🎙️ Standalone audio recording started (output: %@)", audioOutputPath);
+    return true;
+}
 
 // Helper function to cleanup recording resources
 void cleanupRecording() {
@@ -56,6 +145,14 @@ void cleanupRecording() {
     if (isAVFoundationRecording()) {
         stopAVFoundationRecording();
     }
+
+    if (isCameraRecording()) {
+        stopCameraRecording();
+    }
+    if (isStandaloneAudioRecording()) {
+        stopStandaloneAudioRecording();
+    }
+    g_usingStandaloneAudio = false;
     
     g_isRecording = false;
 }
@@ -78,6 +175,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         MRLog(@"⚠️ Still recording after cleanup - forcing stop");
         return Napi::Boolean::New(env, false);
     }
+    g_usingStandaloneAudio = false;
     
     std::string outputPath = info[0].As<Napi::String>().Utf8Value();
     
@@ -90,6 +188,11 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     uint32_t windowID = 0; // Default no window selection
     NSString *audioDeviceId = nil; // Default audio device ID
     NSString *systemAudioDeviceId = nil; // System audio device ID
+    bool captureCamera = false;
+    NSString *cameraDeviceId = nil;
+    NSString *cameraOutputPath = nil;
+    int64_t sessionTimestamp = 0;
+    NSString *audioOutputPath = nil;
     
     if (info.Length() > 1 && info[1].IsObject()) {
         Napi::Object options = info[1].As<Napi::Object>();
@@ -133,6 +236,30 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             std::string sysDeviceId = options.Get("systemAudioDeviceId").As<Napi::String>().Utf8Value();
             systemAudioDeviceId = [NSString stringWithUTF8String:sysDeviceId.c_str()];
         }
+
+        // Camera capture options
+        if (options.Has("captureCamera")) {
+            captureCamera = options.Get("captureCamera").As<Napi::Boolean>();
+        }
+        
+        if (options.Has("cameraDeviceId") && !options.Get("cameraDeviceId").IsNull()) {
+            std::string cameraDevice = options.Get("cameraDeviceId").As<Napi::String>().Utf8Value();
+            cameraDeviceId = [NSString stringWithUTF8String:cameraDevice.c_str()];
+        }
+        
+        if (options.Has("cameraOutputPath") && !options.Get("cameraOutputPath").IsNull()) {
+            std::string cameraPath = options.Get("cameraOutputPath").As<Napi::String>().Utf8Value();
+            cameraOutputPath = [NSString stringWithUTF8String:cameraPath.c_str()];
+        }
+
+        if (options.Has("audioOutputPath") && !options.Get("audioOutputPath").IsNull()) {
+            std::string audioPath = options.Get("audioOutputPath").As<Napi::String>().Utf8Value();
+            audioOutputPath = [NSString stringWithUTF8String:audioPath.c_str()];
+        }
+
+        if (options.Has("sessionTimestamp") && options.Get("sessionTimestamp").IsNumber()) {
+            sessionTimestamp = options.Get("sessionTimestamp").As<Napi::Number>().Int64Value();
+        }
         
         // Display ID
         if (options.Has("displayId") && !options.Get("displayId").IsNull()) {
@@ -172,6 +299,21 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             MRLog(@"🪟 Window ID specified: %u", windowID);
         }
     }
+
+    if (captureCamera && sessionTimestamp == 0) {
+        // Allow native side to auto-generate timestamp if not provided
+        sessionTimestamp = (int64_t)([[NSDate date] timeIntervalSince1970] * 1000.0);
+    }
+
+    bool captureMicrophone = includeMicrophone;
+    bool captureSystemAudio = includeSystemAudio;
+    bool captureAnyAudio = captureMicrophone || captureSystemAudio;
+    NSString *preferredAudioDeviceId = nil;
+    if (captureSystemAudio && systemAudioDeviceId && [systemAudioDeviceId length] > 0) {
+        preferredAudioDeviceId = systemAudioDeviceId;
+    } else if (captureMicrophone && audioDeviceId && [audioDeviceId length] > 0) {
+        preferredAudioDeviceId = audioDeviceId;
+    }
     
     @try {
         // Smart Recording Selection: ScreenCaptureKit vs Alternative
@@ -218,6 +360,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             
             // Try ScreenCaptureKit with extensive safety measures
             @try {
+                if (@available(macOS 12.3, *)) {
                 if ([ScreenCaptureKitRecorder isScreenCaptureKitAvailable]) {
                     MRLog(@"✅ ScreenCaptureKit availability check passed");
                     MRLog(@"🎯 Using ScreenCaptureKit - overlay windows will be automatically excluded");
@@ -231,6 +374,15 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                 sckConfig[@"includeMicrophone"] = @(includeMicrophone);
                 sckConfig[@"audioDeviceId"] = audioDeviceId;
                 sckConfig[@"outputPath"] = [NSString stringWithUTF8String:outputPath.c_str()];
+                if (audioOutputPath) {
+                    sckConfig[@"audioOutputPath"] = audioOutputPath;
+                }
+                if (audioDeviceId) {
+                    sckConfig[@"microphoneDeviceId"] = audioDeviceId;
+                }
+                if (sessionTimestamp != 0) {
+                    sckConfig[@"sessionTimestamp"] = @(sessionTimestamp);
+                }
                 
                 if (!CGRectIsNull(captureRect)) {
                     sckConfig[@"captureRect"] = @{
@@ -245,17 +397,6 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                     NSError *sckError = nil;
                     
                     // Set timeout for ScreenCaptureKit initialization
-                    __block BOOL sckStarted = NO;
-                    __block BOOL sckTimedOut = NO;
-                    
-                    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), 
-                                  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-                        if (!sckStarted && !g_isRecording) {
-                            sckTimedOut = YES;
-                            MRLog(@"⏰ ScreenCaptureKit initialization timeout (3s)");
-                        }
-                    });
-                    
                     // Attempt to start ScreenCaptureKit with safety wrapper
                     @try {
                         if ([ScreenCaptureKitRecorder startRecordingWithConfiguration:sckConfig 
@@ -263,9 +404,16 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                                                                                 error:&sckError]) {
                             
                             // ScreenCaptureKit başlatma başarılı - validation yapmıyoruz
-                            sckStarted = YES;
                             MRLog(@"🎬 RECORDING METHOD: ScreenCaptureKit");
                             MRLog(@"✅ ScreenCaptureKit recording started successfully");
+                            
+                            if (!startCameraIfRequested(captureCamera, &cameraOutputPath, cameraDeviceId, outputPath, sessionTimestamp)) {
+                                MRLog(@"❌ Camera start failed - stopping ScreenCaptureKit session");
+                                [ScreenCaptureKitRecorder stopRecording];
+                                g_isRecording = false;
+                                return Napi::Boolean::New(env, false);
+                            }
+                            
                             g_isRecording = true;
                             return Napi::Boolean::New(env, true);
                         } else {
@@ -280,6 +428,9 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                 } else {
                     NSLog(@"❌ ScreenCaptureKit availability check failed - will fallback to AVFoundation");
                 }
+                } else {
+                    NSLog(@"❌ ScreenCaptureKit not available on this macOS version - falling back to AVFoundation");
+                }
             } @catch (NSException *availabilityException) {
                 NSLog(@"❌ Exception during ScreenCaptureKit availability check - will fallback to AVFoundation: %@", availabilityException.reason);
             }
@@ -333,6 +484,24 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             if (avResult) {
                 MRLog(@"🎥 RECORDING METHOD: AVFoundation");
                 MRLog(@"✅ AVFoundation recording started successfully");
+                
+                if (!startCameraIfRequested(captureCamera, &cameraOutputPath, cameraDeviceId, outputPath, sessionTimestamp)) {
+                    MRLog(@"❌ Camera start failed - stopping AVFoundation session");
+                    stopAVFoundationRecording();
+                    g_isRecording = false;
+                    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);
+                }
+                
                 g_isRecording = true;
                 return Napi::Boolean::New(env, true);
             } else {
@@ -365,7 +534,11 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
         if ([ScreenCaptureKitRecorder isRecording]) {
             MRLog(@"🛑 Stopping ScreenCaptureKit recording");
             [ScreenCaptureKitRecorder stopRecording];
+            if (isCameraRecording()) {
+                stopCameraRecording();
+            }
             g_isRecording = false;
+            g_usingStandaloneAudio = false;
             return Napi::Boolean::New(env, true);
         }
     }
@@ -378,11 +551,25 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
         if (isAVFoundationRecording()) {
             MRLog(@"🛑 Stopping AVFoundation recording");
             if (stopAVFoundationRecording()) {
+                if (g_usingStandaloneAudio && isStandaloneAudioRecording()) {
+                    stopStandaloneAudioRecording();
+                }
+                if (isCameraRecording()) {
+                    stopCameraRecording();
+                }
                 g_isRecording = false;
+                g_usingStandaloneAudio = false;
                 return Napi::Boolean::New(env, true);
             } else {
                 NSLog(@"❌ Failed to stop AVFoundation recording");
+                if (g_usingStandaloneAudio && isStandaloneAudioRecording()) {
+                    stopStandaloneAudioRecording();
+                }
+                if (isCameraRecording()) {
+                    stopCameraRecording();
+                }
                 g_isRecording = false;
+                g_usingStandaloneAudio = false;
                 return Napi::Boolean::New(env, false);
             }
         }
@@ -393,6 +580,9 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     }
     
     MRLog(@"⚠️ No active recording found to stop");
+    if (isCameraRecording()) {
+        stopCameraRecording();
+    }
     g_isRecording = false;
     return Napi::Boolean::New(env, true);
 }
@@ -503,65 +693,182 @@ Napi::Value GetAudioDevices(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
     @try {
-        NSMutableArray *devices = [NSMutableArray array];
-        
-        // Get all audio devices
-        // Audio device enumeration removed - ScreenCaptureKit handles audio internally
-        NSLog(@"🎵 Audio device enumeration disabled - using ScreenCaptureKit internal audio");
-        
-        // Add default system audio entry
-        [devices addObject:@{
-            @"id": @"default", 
-            @"name": @"Default Audio Device",
-            @"isDefault": @YES
-        }];
+        NSArray<NSDictionary *> *devices = listAudioCaptureDevices();
+        if (!devices) {
+            return Napi::Array::New(env, 0);
+        }
         
-        // Convert to NAPI array
         Napi::Array result = Napi::Array::New(env, devices.count);
         for (NSUInteger i = 0; i < devices.count; i++) {
             NSDictionary *device = devices[i];
+            if (![device isKindOfClass:[NSDictionary class]]) {
+                continue;
+            }
             Napi::Object deviceObj = Napi::Object::New(env);
-            
-            // Safe string conversion with null checks
             NSString *deviceId = device[@"id"];
-            NSString *deviceName = device[@"name"]; 
-            NSString *deviceManufacturer = device[@"manufacturer"];
+            NSString *deviceName = device[@"name"];
+            NSString *manufacturer = device[@"manufacturer"];
             NSNumber *isDefault = device[@"isDefault"];
+            NSNumber *transportType = device[@"transportType"];
             
-            if (deviceId && [deviceId isKindOfClass:[NSString class]]) {
-                deviceObj.Set("id", Napi::String::New(env, [deviceId UTF8String]));
-            } else {
-                deviceObj.Set("id", Napi::String::New(env, "default"));
+            deviceObj.Set("id", Napi::String::New(env, deviceId ? [deviceId UTF8String] : ""));
+            deviceObj.Set("name", Napi::String::New(env, deviceName ? [deviceName UTF8String] : "Unknown Audio Device"));
+            if (manufacturer && [manufacturer isKindOfClass:[NSString class]]) {
+                deviceObj.Set("manufacturer", Napi::String::New(env, [manufacturer UTF8String]));
             }
-            
-            if (deviceName && [deviceName isKindOfClass:[NSString class]]) {
-                deviceObj.Set("name", Napi::String::New(env, [deviceName UTF8String]));
-            } else {
-                deviceObj.Set("name", Napi::String::New(env, "Default Audio Device"));
-            }
-            
-            if (deviceManufacturer && [deviceManufacturer isKindOfClass:[NSString class]]) {
-                deviceObj.Set("manufacturer", Napi::String::New(env, [deviceManufacturer UTF8String]));
-            } else {
-                deviceObj.Set("manufacturer", Napi::String::New(env, "System"));
-            }
-            
             if (isDefault && [isDefault isKindOfClass:[NSNumber class]]) {
                 deviceObj.Set("isDefault", Napi::Boolean::New(env, [isDefault boolValue]));
-            } else {
-                deviceObj.Set("isDefault", Napi::Boolean::New(env, true));
             }
-            
+            if (transportType && [transportType isKindOfClass:[NSNumber class]]) {
+                deviceObj.Set("transportType", Napi::Number::New(env, [transportType integerValue]));
+            }
             result[i] = deviceObj;
         }
-        
         return result;
-        
     } @catch (NSException *exception) {
         return Napi::Array::New(env, 0);
     }
 }
 
+Napi::Value GetCameraDevices(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::Array result = Napi::Array::New(env);
+    
+    @try {
+        @autoreleasepool {
+            NSArray<NSDictionary *> *devices = listCameraDevices();
+            if (!devices) {
+                return result;
+            }
+            
+            NSUInteger index = 0;
+            for (id entry in devices) {
+                if (![entry isKindOfClass:[NSDictionary class]]) {
+                    continue;
+                }
+                
+                NSDictionary *camera = (NSDictionary *)entry;
+                Napi::Object cameraObj = Napi::Object::New(env);
+                
+                NSString *identifier = camera[@"id"];
+                NSString *name = camera[@"name"];
+                NSString *model = camera[@"model"];
+                NSString *manufacturer = camera[@"manufacturer"];
+                NSString *position = camera[@"position"];
+                NSNumber *transportType = camera[@"transportType"];
+                NSNumber *isConnected = camera[@"isConnected"];
+                NSNumber *hasFlash = camera[@"hasFlash"];
+                NSNumber *supportsDepth = camera[@"supportsDepth"];
+                
+                if (identifier && [identifier isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("id", Napi::String::New(env, [identifier UTF8String]));
+                } else {
+                    cameraObj.Set("id", Napi::String::New(env, ""));
+                }
+                
+                if (name && [name isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("name", Napi::String::New(env, [name UTF8String]));
+                } else {
+                    cameraObj.Set("name", Napi::String::New(env, "Unknown Camera"));
+                }
+                
+                if (model && [model isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("model", Napi::String::New(env, [model UTF8String]));
+                }
+                
+                if (manufacturer && [manufacturer isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("manufacturer", Napi::String::New(env, [manufacturer UTF8String]));
+                }
+                
+                if (position && [position isKindOfClass:[NSString class]]) {
+                    cameraObj.Set("position", Napi::String::New(env, [position UTF8String]));
+                }
+                
+                if (transportType && [transportType isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("transportType", Napi::Number::New(env, [transportType integerValue]));
+                }
+                
+                if (isConnected && [isConnected isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("isConnected", Napi::Boolean::New(env, [isConnected boolValue]));
+                }
+                
+                if (hasFlash && [hasFlash isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("hasFlash", Napi::Boolean::New(env, [hasFlash boolValue]));
+                }
+                
+                if (supportsDepth && [supportsDepth isKindOfClass:[NSNumber class]]) {
+                    cameraObj.Set("supportsDepth", Napi::Boolean::New(env, [supportsDepth boolValue]));
+                }
+                
+                NSDictionary *maxResolution = camera[@"maxResolution"];
+                if (maxResolution && [maxResolution isKindOfClass:[NSDictionary class]]) {
+                    Napi::Object maxResObj = Napi::Object::New(env);
+                    
+                    NSNumber *width = maxResolution[@"width"];
+                    NSNumber *height = maxResolution[@"height"];
+                    NSNumber *frameRate = maxResolution[@"maxFrameRate"];
+                    
+                    if (width && [width isKindOfClass:[NSNumber class]]) {
+                        maxResObj.Set("width", Napi::Number::New(env, [width integerValue]));
+                    }
+                    if (height && [height isKindOfClass:[NSNumber class]]) {
+                        maxResObj.Set("height", Napi::Number::New(env, [height integerValue]));
+                    }
+                    if (frameRate && [frameRate isKindOfClass:[NSNumber class]]) {
+                        maxResObj.Set("maxFrameRate", Napi::Number::New(env, [frameRate doubleValue]));
+                    }
+                    
+                    cameraObj.Set("maxResolution", maxResObj);
+                }
+                
+                result[index++] = cameraObj;
+            }
+        }
+        
+        return result;
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Exception while listing camera devices: %@", exception.reason);
+        return result;
+    }
+}
+
+Napi::Value GetCameraRecordingPath(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    @try {
+        NSString *path = currentCameraRecordingPath();
+        if (!path || [path length] == 0) {
+            return env.Null();
+        }
+        return Napi::String::New(env, [path UTF8String]);
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Exception while reading camera output path: %@", exception.reason);
+        return env.Null();
+    }
+}
+
+Napi::Value GetAudioRecordingPath(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    @try {
+        NSString *path = nil;
+        if (@available(macOS 12.3, *)) {
+            path = ScreenCaptureKitCurrentAudioPath();
+        }
+        if ([path isKindOfClass:[NSArray class]]) {
+            path = [(NSArray *)path firstObject];
+        }
+        if (!path || [path length] == 0) {
+            path = currentStandaloneAudioRecordingPath();
+        }
+        if (!path || [path length] == 0) {
+            return env.Null();
+        }
+        return Napi::String::New(env, [path UTF8String]);
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Exception while reading audio output path: %@", exception.reason);
+        return env.Null();
+    }
+}
+
 // NAPI Function: Get Displays
 Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -892,12 +1199,6 @@ Napi::Value CheckPermissions(const Napi::CallbackInfo& info) {
         BOOL forceAVFoundation = (getenv("FORCE_AVFOUNDATION") != NULL);
         
         // Electron detection
-        BOOL isElectron = (NSBundle.mainBundle.bundleIdentifier && 
-                          [NSBundle.mainBundle.bundleIdentifier containsString:@"electron"]) ||
-                         (NSProcessInfo.processInfo.processName && 
-                          [NSProcessInfo.processInfo.processName containsString:@"Electron"]) ||
-                         (NSProcessInfo.processInfo.environment[@"ELECTRON_RUN_AS_NODE"] != nil);
-        
         NSLog(@"🔒 Permission check for macOS %ld.%ld.%ld", 
               (long)osVersion.majorVersion, (long)osVersion.minorVersion, (long)osVersion.patchVersion);
         
@@ -945,27 +1246,18 @@ Napi::Value CheckPermissions(const Napi::CallbackInfo& info) {
             NSLog(@"🔒 Screen recording: No permission system (macOS < 10.15)");
         }
         
-        // Check audio permission based on framework
-        bool hasAudioPermission = true;
-        
-        if (willUseScreenCaptureKit) {
-            // ScreenCaptureKit handles audio permissions internally
-            hasAudioPermission = true;
-            NSLog(@"🔒 Audio permission: Handled internally by ScreenCaptureKit");
-            
-        } else if (willUseAVFoundation) {
-            // For AVFoundation, we don't enforce audio permissions
-            // Recording can continue without audio if needed
-            hasAudioPermission = true;
-            NSLog(@"🔒 Audio permission: Will be requested during recording by AVFoundation");
+        bool audioPermissionGranted = hasAudioPermission();
+        NSLog(@"🔒 Audio permission: %s", audioPermissionGranted ? "GRANTED" : "DENIED");
+        if (!audioPermissionGranted) {
+            NSLog(@"📝 Grant microphone access in System Settings > Privacy & Security > Microphone");
         }
         
         NSLog(@"🔒 Final permission status:");
         NSLog(@"   Framework: %s", willUseScreenCaptureKit ? "ScreenCaptureKit" : "AVFoundation");
         NSLog(@"   Screen Recording: %s", hasScreenPermission ? "GRANTED" : "DENIED");
-        NSLog(@"   Audio: %s", hasAudioPermission ? "READY" : "NOT READY");
+        NSLog(@"   Audio: %s", audioPermissionGranted ? "READY" : "NOT READY");
         
-        return Napi::Boolean::New(env, hasScreenPermission && hasAudioPermission);
+        return Napi::Boolean::New(env, hasScreenPermission && audioPermissionGranted);
         
     } @catch (NSException *exception) {
         NSLog(@"❌ Exception in permission check: %@", exception.reason);
@@ -979,6 +1271,9 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set(Napi::String::New(env, "stopRecording"), Napi::Function::New(env, StopRecording));
 
     exports.Set(Napi::String::New(env, "getAudioDevices"), Napi::Function::New(env, GetAudioDevices));
+    exports.Set(Napi::String::New(env, "getCameraDevices"), Napi::Function::New(env, GetCameraDevices));
+    exports.Set(Napi::String::New(env, "getCameraRecordingPath"), Napi::Function::New(env, GetCameraRecordingPath));
+    exports.Set(Napi::String::New(env, "getAudioRecordingPath"), Napi::Function::New(env, GetAudioRecordingPath));
     exports.Set(Napi::String::New(env, "getDisplays"), Napi::Function::New(env, GetDisplays));
     exports.Set(Napi::String::New(env, "getWindows"), Napi::Function::New(env, GetWindows));
     exports.Set(Napi::String::New(env, "getRecordingStatus"), Napi::Function::New(env, GetRecordingStatus));

package/src/screen_capture_kit.h

@@ -2,7 +2,7 @@
 #import <ScreenCaptureKit/ScreenCaptureKit.h>
 // NO AVFoundation - Pure ScreenCaptureKit implementation
 
-API_AVAILABLE(macos(15.0))
+API_AVAILABLE(macos(12.3))
 @interface ScreenCaptureKitRecorder : NSObject
 
 + (BOOL)isScreenCaptureKitAvailable;
@@ -16,4 +16,4 @@ API_AVAILABLE(macos(15.0))
 + (void)finalizeVideoWriter;
 + (void)cleanupVideoWriter;
 
-@end
+@end