node-mac-recorder 2.1.2 → 2.2.1

package/binding.gyp

@@ -21,25 +21,42 @@
       "xcode_settings": {
         "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
         "CLANG_CXX_LIBRARY": "libc++",
-        "MACOSX_DEPLOYMENT_TARGET": "10.15",
+        "MACOSX_DEPLOYMENT_TARGET": "12.3",
+<<<<<<< HEAD
+=======
+        "ARCHS": ["arm64"],
+        "VALID_ARCHS": ["arm64"],
+>>>>>>> screencapture
         "OTHER_CFLAGS": [
-          "-ObjC++"
-        ]
+          "-ObjC++",
+          "-fmodules"
+        ],
+        "CLANG_ENABLE_OBJC_ARC": "YES"
       },
       "link_settings": {
         "libraries": [
+<<<<<<< HEAD
+=======
+          "-framework ScreenCaptureKit",
           "-framework AVFoundation",
           "-framework CoreMedia",
           "-framework CoreVideo",
+>>>>>>> screencapture
           "-framework Foundation",
           "-framework AppKit",
-          "-framework ScreenCaptureKit",
           "-framework ApplicationServices",
           "-framework Carbon",
-          "-framework Accessibility"
+          "-framework Accessibility",
+          "-framework CoreAudio",
+          "-framework AVFoundation",
+          "-framework CoreMedia",
+          "-framework CoreVideo"
         ]
       },
-      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ]
+      "defines": [ 
+        "NAPI_DISABLE_CPP_EXCEPTIONS",
+        "USE_SCREENCAPTUREKIT=1"
+      ]
     }
   ]
 } 

package/index.js

@@ -129,6 +129,7 @@ class MacRecorder extends EventEmitter {
 			audioDeviceId: options.audioDeviceId || null, // null = default device
 			systemAudioDeviceId: options.systemAudioDeviceId || null, // null = auto-detect system audio device
 			captureArea: options.captureArea || null,
+<<<<<<< HEAD
 			useScreenCaptureKit: options.useScreenCaptureKit || false,
 			excludedAppBundleIds: options.excludedAppBundleIds || [],
 			excludedPIDs: options.excludedPIDs || [],
@@ -137,6 +138,13 @@ class MacRecorder extends EventEmitter {
 				typeof options.autoExcludeSelf === "boolean"
 					? options.autoExcludeSelf
 					: !!(process.versions && process.versions.electron),
+=======
+			// Exclusion options
+			excludeCurrentApp: options.excludeCurrentApp || false,
+			excludeWindowIds: Array.isArray(options.excludeWindowIds)
+				? options.excludeWindowIds
+				: [],
+>>>>>>> screencapture
 		};
 	}
 
@@ -297,11 +305,17 @@ class MacRecorder extends EventEmitter {
 					windowId: this.options.windowId || null, // null = tam ekran
 					audioDeviceId: this.options.audioDeviceId || null, // null = default device
 					systemAudioDeviceId: this.options.systemAudioDeviceId || null, // null = auto-detect system audio device
+<<<<<<< HEAD
 					useScreenCaptureKit: this.options.useScreenCaptureKit || false,
 					excludedAppBundleIds: this.options.excludedAppBundleIds || [],
 					excludedPIDs: this.options.excludedPIDs || [],
 					excludedWindowIds: this.options.excludedWindowIds || [],
 					autoExcludeSelf: this.options.autoExcludeSelf === true,
+=======
+					// Exclusion options passthrough
+					excludeCurrentApp: this.options.excludeCurrentApp || false,
+					excludeWindowIds: this.options.excludeWindowIds || [],
+>>>>>>> screencapture
 				};
 
 				// Manuel captureArea varsa onu kullan

package/package.json

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

package/scripts/test-exclude.js

@@ -0,0 +1,72 @@
+/*
+ Simple test runner: starts a 2s recording with ScreenCaptureKit and exclusions.
+ */
+const fs = require("fs");
+const path = require("path");
+const MacRecorder = require("..");
+
+async function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function main() {
+	const recorder = new MacRecorder();
+	const outDir = path.resolve(process.cwd(), "test-output");
+	const outPath = path.join(outDir, `sc-exclude-${Date.now()}.mov`);
+	await fs.promises.mkdir(outDir, { recursive: true });
+
+	console.log("[TEST] Starting 2s recording with SC exclusions...");
+	// Try to ensure overlays are not active in this process
+
+	const perms = await recorder.checkPermissions();
+	if (!perms?.screenRecording) {
+		console.error(
+			"[TEST] Screen Recording permission is not granted. Enable it in System Settings → Privacy & Security → Screen Recording for Terminal/Node, then re-run."
+		);
+		process.exit(1);
+	}
+
+	try {
+		await recorder.startRecording(outPath, {
+			useScreenCaptureKit: true,
+			captureCursor: false,
+			excludedAppBundleIds: ["com.apple.Safari"],
+		});
+	} catch (e) {
+		console.error("[TEST] Failed to start recording:", e.message);
+		process.exit(1);
+	}
+
+	await sleep(2000);
+
+	try {
+		const result = await recorder.stopRecording();
+		console.log("[TEST] Stopped. Result:", result);
+	} catch (e) {
+		console.error("[TEST] Failed to stop recording:", e.message);
+		process.exit(1);
+	}
+
+	// SCRecordingOutput write may be async; wait up to 10s for the file
+	const deadline = Date.now() + 10000;
+	let stats = null;
+	while (Date.now() < deadline) {
+		if (fs.existsSync(outPath)) {
+			stats = fs.statSync(outPath);
+			if (stats.size > 0) break;
+		}
+		await sleep(200);
+	}
+
+	if (stats && fs.existsSync(outPath)) {
+		console.log(`[TEST] Output saved: ${outPath} (${stats.size} bytes)`);
+	} else {
+		console.error("[TEST] Output file not found or empty:", outPath);
+		process.exit(1);
+	}
+}
+
+main().catch((e) => {
+	console.error("[TEST] Unhandled error:", e);
+	process.exit(1);
+});

package/src/audio_capture.mm

@@ -1,9 +1,11 @@
+#import <ScreenCaptureKit/ScreenCaptureKit.h>
 #import <AVFoundation/AVFoundation.h>
 #import <CoreAudio/CoreAudio.h>
 
 @interface AudioCapture : NSObject
 
 + (NSArray *)getAudioDevices;
++ (NSArray *)getSystemAudioDevices;
 + (BOOL)hasAudioPermission;
 + (void)requestAudioPermission:(void(^)(BOOL granted))completion;
 
@@ -14,25 +16,39 @@
 + (NSArray *)getAudioDevices {
     NSMutableArray *devices = [NSMutableArray array];
     
-    // Get all audio devices
-    NSArray *audioDevices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeAudio];
+    // Get microphone devices using AVFoundation
+    AVCaptureDeviceDiscoverySession *discoverySession = [AVCaptureDeviceDiscoverySession 
+        discoverySessionWithDeviceTypes:@[AVCaptureDeviceTypeBuiltInMicrophone, AVCaptureDeviceTypeExternalUnknown]
+        mediaType:AVMediaTypeAudio
+        position:AVCaptureDevicePositionUnspecified];
+    NSArray *audioDevices = discoverySession.devices;
     
     for (AVCaptureDevice *device in audioDevices) {
         NSDictionary *deviceInfo = @{
             @"id": device.uniqueID,
             @"name": device.localizedName,
             @"manufacturer": device.manufacturer ?: @"Unknown",
+            @"type": @"microphone",
             @"isDefault": @([device isEqual:[AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio]])
         };
         
         [devices addObject:deviceInfo];
     }
     
-    // Also get system audio devices using Core Audio
+    // Add system audio devices using Core Audio API
+    NSArray *systemDevices = [self getSystemAudioDevices];
+    [devices addObjectsFromArray:systemDevices];
+    
+    return [devices copy];
+}
+
++ (NSArray *)getSystemAudioDevices {
+    NSMutableArray *devices = [NSMutableArray array];
+    
     AudioObjectPropertyAddress propertyAddress = {
         kAudioHardwarePropertyDevices,
         kAudioObjectPropertyScopeGlobal,
-        kAudioObjectPropertyElementMaster
+        kAudioObjectPropertyElementMain  // Changed from kAudioObjectPropertyElementMaster (deprecated)
     };
     
     UInt32 dataSize = 0;
@@ -49,37 +65,41 @@
                 AudioDeviceID deviceID = audioDeviceIDs[i];
                 
                 // Get device name
-                propertyAddress.mSelector = kAudioDevicePropertyDeviceNameCFString;
-                propertyAddress.mScope = kAudioObjectPropertyScopeGlobal;
-                
                 CFStringRef deviceName = NULL;
-                dataSize = sizeof(deviceName);
+                UInt32 size = sizeof(deviceName);
+                AudioObjectPropertyAddress nameAddress = {
+                    kAudioDevicePropertyDeviceNameCFString,
+                    kAudioDevicePropertyScopeOutput,  // Focus on output devices for system audio
+                    kAudioObjectPropertyElementMain
+                };
                 
-                status = AudioObjectGetPropertyData(deviceID, &propertyAddress, 0, NULL, &dataSize, &deviceName);
+                status = AudioObjectGetPropertyData(deviceID, &nameAddress, 0, NULL, &size, &deviceName);
                 
                 if (status == kAudioHardwareNoError && deviceName) {
-                    // Check if it's an input device
-                    propertyAddress.mSelector = kAudioDevicePropertyStreamConfiguration;
-                    propertyAddress.mScope = kAudioDevicePropertyScopeInput;
+                    // Check if this is an output device
+                    AudioObjectPropertyAddress streamAddress = {
+                        kAudioDevicePropertyStreams,
+                        kAudioDevicePropertyScopeOutput,
+                        kAudioObjectPropertyElementMain
+                    };
                     
-                    AudioObjectGetPropertyDataSize(deviceID, &propertyAddress, 0, NULL, &dataSize);
+                    UInt32 streamSize = 0;
+                    status = AudioObjectGetPropertyDataSize(deviceID, &streamAddress, 0, NULL, &streamSize);
                     
-                    if (dataSize > 0) {
-                        AudioBufferList *bufferList = (AudioBufferList *)malloc(dataSize);
-                        AudioObjectGetPropertyData(deviceID, &propertyAddress, 0, NULL, &dataSize, bufferList);
+                    if (status == kAudioHardwareNoError && streamSize > 0) {
+                        // This is an output device - can be used for system audio capture
+                        const char *name = CFStringGetCStringPtr(deviceName, kCFStringEncodingUTF8);
+                        NSString *deviceNameStr = name ? [NSString stringWithUTF8String:name] : @"Unknown Device";
                         
-                        if (bufferList->mNumberBuffers > 0) {
-                            NSDictionary *deviceInfo = @{
-                                @"id": @(deviceID),
-                                @"name": (__bridge NSString *)deviceName,
-                                @"type": @"System Audio Input",
-                                @"isSystemDevice": @YES
-                            };
-                            
-                            [devices addObject:deviceInfo];
-                        }
+                        NSDictionary *deviceInfo = @{
+                            @"id": [NSString stringWithFormat:@"%u", deviceID],
+                            @"name": deviceNameStr,
+                            @"manufacturer": @"System",
+                            @"type": @"system_audio",
+                            @"isDefault": @(NO)  // We'll determine default separately if needed
+                        };
                         
-                        free(bufferList);
+                        [devices addObject:deviceInfo];
                     }
                     
                     CFRelease(deviceName);
@@ -94,23 +114,59 @@
 }
 
 + (BOOL)hasAudioPermission {
-    if (@available(macOS 10.14, *)) {
-        AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeAudio];
-        return status == AVAuthorizationStatusAuthorized;
-    }
-    return YES; // Older versions don't require explicit permission
+    // Check microphone permission using AVFoundation
+    AVAuthorizationStatus authStatus = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeAudio];
+    return authStatus == AVAuthorizationStatusAuthorized;
 }
 
 + (void)requestAudioPermission:(void(^)(BOOL granted))completion {
-    if (@available(macOS 10.14, *)) {
-        [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:^(BOOL granted) {
-            dispatch_async(dispatch_get_main_queue(), ^{
+    [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:^(BOOL granted) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            if (completion) {
                 completion(granted);
-            });
-        }];
-    } else {
-        completion(YES);
+            }
+        });
+    }];
+}
+
+@end
+
+// ScreenCaptureKit Audio Configuration Helper
+API_AVAILABLE(macos(12.3))
+@interface SCKAudioConfiguration : NSObject
+
++ (BOOL)configureAudioForStream:(SCStreamConfiguration *)config 
+                 includeMicrophone:(BOOL)includeMicrophone
+               includeSystemAudio:(BOOL)includeSystemAudio
+                  microphoneDevice:(NSString *)micDeviceID
+                systemAudioDevice:(NSString *)sysDeviceID;
+
+@end
+
+@implementation SCKAudioConfiguration
+
++ (BOOL)configureAudioForStream:(SCStreamConfiguration *)config 
+                 includeMicrophone:(BOOL)includeMicrophone
+               includeSystemAudio:(BOOL)includeSystemAudio
+                  microphoneDevice:(NSString *)micDeviceID
+                systemAudioDevice:(NSString *)sysDeviceID {
+    
+    // Configure system audio capture (requires macOS 13.0+)
+    if (@available(macOS 13.0, *)) {
+        config.capturesAudio = includeSystemAudio;
+        config.excludesCurrentProcessAudio = YES;
+        
+        if (includeSystemAudio) {
+            // ScreenCaptureKit will capture system audio from the selected content
+            // Quality settings
+            config.channelCount = 2;  // Stereo
+            config.sampleRate = 48000; // 48kHz
+        } else {
+            config.capturesAudio = NO;
+        }
     }
+    
+    return YES;
 }
 
-@end 
+@end

package/src/cursor_tracker.mm

@@ -168,7 +168,7 @@ void writeToFile(NSDictionary *cursorData) {
                                                                options:0
                                                                  error:&error];
             if (jsonData && !error) {
-                NSString *jsonString = [[[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding] autorelease];
+                NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
                 
                 if (g_isFirstWrite) {
                     // İlk yazma - array başlat
@@ -292,7 +292,6 @@ void cleanupCursorTracking() {
     }
     
     if (g_timerTarget) {
-        [g_timerTarget autorelease];
         g_timerTarget = nil;
     }
     
@@ -352,12 +351,12 @@ Napi::Value StartCursorTracking(const Napi::CallbackInfo& info) {
     @try {
         // Dosyayı oluştur ve aç
         g_outputPath = [NSString stringWithUTF8String:outputPath.c_str()];
-        g_fileHandle = [[NSFileHandle fileHandleForWritingAtPath:g_outputPath] retain];
+        g_fileHandle = [NSFileHandle fileHandleForWritingAtPath:g_outputPath];
         
         if (!g_fileHandle) {
             // Dosya yoksa oluştur
             [[NSFileManager defaultManager] createFileAtPath:g_outputPath contents:nil attributes:nil];
-            g_fileHandle = [[NSFileHandle fileHandleForWritingAtPath:g_outputPath] retain];
+            g_fileHandle = [NSFileHandle fileHandleForWritingAtPath:g_outputPath];
         }
         
         if (!g_fileHandle) {