node-mac-recorder 1.2.9 → 1.2.11

package/.claude/settings.local.json

@@ -6,7 +6,11 @@
       "Bash(rm:*)",
       "Bash(python3:*)",
       "Bash(grep:*)",
-      "Bash(cat:*)"
+      "Bash(cat:*)",
+      "Bash(brew install:*)",
+      "Bash(open:*)",
+      "Bash(curl:*)",
+      "Bash(system_profiler:*)"
     ],
     "deny": []
   }

package/README.md

@@ -93,6 +93,7 @@ await recorder.startRecording("./recording.mov", {
 	includeMicrophone: false, // Enable microphone (default: false)
 	includeSystemAudio: true, // Enable system audio (default: true)
 	audioDeviceId: "device-id", // Specific audio input device (default: system default)
+	systemAudioDeviceId: "system-device-id", // Specific system audio device (auto-detected by default)
 
 	// Display & Window Selection
 	displayId: 0, // Display index (null = main display)
@@ -348,19 +349,62 @@ await new Promise((resolve) => setTimeout(resolve, 8000));
 await recorder.stopRecording();
 ```
 
-### Audio-Only System Recording
+### Advanced System Audio Recording
 
 ```javascript
 const recorder = new MacRecorder();
 
-// Record system audio without microphone
-await recorder.startRecording("./system-audio.mov", {
-	includeMicrophone: false,
-	includeSystemAudio: true,
-	captureArea: { x: 0, y: 0, width: 1, height: 1 }, // Minimal video
+// List available audio devices to find system audio devices
+const audioDevices = await recorder.getAudioDevices();
+console.log("Available audio devices:");
+audioDevices.forEach((device, i) => {
+	console.log(`${i + 1}. ${device.name} (ID: ${device.id})`);
 });
+
+// Find system audio device (like BlackHole, Soundflower, etc.)
+const systemAudioDevice = audioDevices.find(device => 
+	device.name.toLowerCase().includes('blackhole') ||
+	device.name.toLowerCase().includes('soundflower') ||
+	device.name.toLowerCase().includes('loopback') ||
+	device.name.toLowerCase().includes('aggregate')
+);
+
+if (systemAudioDevice) {
+	console.log(`Using system audio device: ${systemAudioDevice.name}`);
+	
+	// Record with specific system audio device
+	await recorder.startRecording("./system-audio-specific.mov", {
+		includeMicrophone: false,
+		includeSystemAudio: true,
+		systemAudioDeviceId: systemAudioDevice.id, // Specify exact device
+		captureArea: { x: 0, y: 0, width: 1, height: 1 }, // Minimal video
+	});
+} else {
+	console.log("No system audio device found. Installing BlackHole or Soundflower recommended.");
+	
+	// Record with default system audio capture (may not work without virtual audio device)
+	await recorder.startRecording("./system-audio-default.mov", {
+		includeMicrophone: false,
+		includeSystemAudio: true, // Auto-detect system audio device
+		captureArea: { x: 0, y: 0, width: 1, height: 1 },
+	});
+}
+
+// Record for 10 seconds
+await new Promise(resolve => setTimeout(resolve, 10000));
+await recorder.stopRecording();
 ```
 
+**System Audio Setup:**
+
+For reliable system audio capture, install a virtual audio device:
+
+1. **BlackHole** (Free): https://github.com/ExistentialAudio/BlackHole
+2. **Soundflower** (Free): https://github.com/mattingalls/Soundflower  
+3. **Loopback** (Paid): https://rogueamoeba.com/loopback/
+
+These create aggregate audio devices that the package can detect and use for system audio capture.
+
 ### Event-Driven Recording
 
 ```javascript

package/debug-audio.js

@@ -0,0 +1,79 @@
+const MacRecorder = require('./index');
+
+async function debugAudio() {
+    const recorder = new MacRecorder();
+    
+    console.log('🔍 SES CİHAZI DEBUG RAPORU\n');
+    
+    try {
+        // Tüm ses cihazlarını detayları ile listele
+        const devices = await recorder.getAudioDevices();
+        console.log('📋 TÜM SES CİHAZLARI:');
+        devices.forEach((device, index) => {
+            console.log(`${index + 1}. ${device.name}`);
+            console.log(`   ID: ${device.id || 'N/A'}`);
+            console.log(`   Type: ${device.type || 'N/A'}`);
+            console.log(`   Manufacturer: ${device.manufacturer || 'N/A'}`);
+            console.log(`   Default: ${device.isDefault ? 'Yes' : 'No'}`);
+            console.log('');
+        });
+        
+        // Sistem sesi için uygun cihazları bul
+        const systemDevices = devices.filter(device => {
+            const name = device.name.toLowerCase();
+            return name.includes('aggregate') || 
+                   name.includes('blackhole') || 
+                   name.includes('soundflower') || 
+                   name.includes('loopback') ||
+                   name.includes('system') ||
+                   name.includes('imobie');
+        });
+        
+        console.log('🎵 SİSTEM SESİ İÇİN UYGUN CİHAZLAR:');
+        if (systemDevices.length > 0) {
+            systemDevices.forEach((device, index) => {
+                console.log(`${index + 1}. ${device.name} (ID: ${device.id})`);
+            });
+        } else {
+            console.log('❌ Sistem sesi cihazı bulunamadı!');
+        }
+        
+        console.log('\n💡 ÇÖZÜMLERİ:');
+        console.log('1. BlackHole kur: https://github.com/ExistentialAudio/BlackHole/releases');
+        console.log('2. Audio MIDI Setup ile Aggregate Device oluştur');
+        console.log('3. Sistem sesini aggregate device\'a yönlendir');
+        
+        console.log('\n🔧 MANUAL AGGREGATE DEVICE OLUŞTURMA:');
+        console.log('1. Spotlight\'ta "Audio MIDI Setup" ara ve aç');
+        console.log('2. Sol alt köşedeki "+" butonuna tıkla');
+        console.log('3. "Create Aggregate Device" seç');
+        console.log('4. Hem built-in output hem de built-in input\'u seç');
+        console.log('5. İsim ver (örn: "System Audio Capture")');
+        console.log('6. System Preferences > Sound > Output\'ta yeni cihazı seç');
+        
+        // Test kayıt yap
+        console.log('\n🧪 TEST KAYIT YAPILIYOR...');
+        console.log('🎵 Şimdi müzik çal veya YouTube video aç!');
+        
+        const testDevice = systemDevices[0]; // İlk sistem ses cihazını kullan
+        
+        await recorder.startRecording('./test-output/debug-audio.mov', {
+            includeSystemAudio: true,
+            includeMicrophone: false,
+            systemAudioDeviceId: testDevice?.id,
+            captureArea: { x: 0, y: 0, width: 300, height: 200 }
+        });
+        
+        // 3 saniye kayıt
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        await recorder.stopRecording();
+        
+        console.log('✅ Test kayıt tamamlandı: ./test-output/debug-audio.mov');
+        console.log('🔍 Dosyayı QuickTime Player ile açıp ses kontrolü yap');
+        
+    } catch (error) {
+        console.error('❌ Debug hatası:', error.message);
+    }
+}
+
+debugAudio();

package/index.js

@@ -111,11 +111,12 @@ class MacRecorder extends EventEmitter {
 	setOptions(options = {}) {
 		this.options = {
 			includeMicrophone: options.includeMicrophone || false,
-			includeSystemAudio: options.includeSystemAudio !== false, // Default true
+			includeSystemAudio: options.includeSystemAudio !== false, // Default true unless explicitly disabled
 			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,
 		};
 	}
@@ -163,7 +164,7 @@ class MacRecorder extends EventEmitter {
 							targetWindow.y >= display.y &&
 							targetWindow.y < display.y + displayHeight
 						) {
-							targetDisplayId = i;
+							targetDisplayId = display.id; // Use actual display ID, not array index
 							// Koordinatları display'e göre normalize et
 							adjustedX = targetWindow.x - display.x;
 							adjustedY = targetWindow.y - display.y;
@@ -175,7 +176,7 @@ class MacRecorder extends EventEmitter {
 					if (targetDisplayId === null) {
 						const mainDisplay = displays.find((d) => d.x === 0 && d.y === 0);
 						if (mainDisplay) {
-							targetDisplayId = displays.indexOf(mainDisplay);
+							targetDisplayId = mainDisplay.id; // Use actual display ID, not array index
 							adjustedX = Math.max(
 								0,
 								Math.min(
@@ -200,7 +201,7 @@ class MacRecorder extends EventEmitter {
 						this.options.displayId = targetDisplayId;
 
 						// Recording için display bilgisini sakla (cursor capture için)
-						const targetDisplay = displays[targetDisplayId];
+						const targetDisplay = displays.find(d => d.id === targetDisplayId);
 						this.recordingDisplayInfo = {
 							displayId: targetDisplayId,
 							x: targetDisplay.x,
@@ -233,8 +234,8 @@ class MacRecorder extends EventEmitter {
 		if (this.options.displayId !== null && !this.recordingDisplayInfo) {
 			try {
 				const displays = await this.getDisplays();
-				if (this.options.displayId < displays.length) {
-					const targetDisplay = displays[this.options.displayId];
+				const targetDisplay = displays.find(d => d.id === this.options.displayId);
+				if (targetDisplay) {
 					this.recordingDisplayInfo = {
 						displayId: this.options.displayId,
 						x: targetDisplay.x,
@@ -261,11 +262,12 @@ class MacRecorder extends EventEmitter {
 				// Native kayıt başlat
 				const recordingOptions = {
 					includeMicrophone: this.options.includeMicrophone || false,
-					includeSystemAudio: this.options.includeSystemAudio !== false, // Default true
+					includeSystemAudio: this.options.includeSystemAudio !== false, // Default true unless explicitly disabled
 					captureCursor: this.options.captureCursor || false,
 					displayId: this.options.displayId || null, // null = ana ekran
 					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
 				};
 
 				// Manuel captureArea varsa onu kullan

package/package.json

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

package/quick-test.js

@@ -0,0 +1,50 @@
+const MacRecorder = require('./index');
+
+async function quickTest() {
+    const recorder = new MacRecorder();
+    
+    console.log('🚀 Hızlı Sistem Sesi Testi\n');
+    
+    try {
+        // Ses cihazlarını listele
+        const devices = await recorder.getAudioDevices();
+        console.log('🎤 Mevcut ses cihazları:');
+        devices.forEach((d, i) => console.log(`${i+1}. ${d.name}`));
+        
+        // Sistem sesi cihazı var mı?
+        const sysDevice = devices.find(d => 
+            d.name.toLowerCase().includes('aggregate') ||
+            d.name.toLowerCase().includes('blackhole') ||
+            d.name.toLowerCase().includes('soundflower')
+        );
+        
+        if (sysDevice) {
+            console.log(`\n✅ Sistem sesi cihazı bulundu: ${sysDevice.name}`);
+            console.log('🎵 Sistem sesi yakalama çalışmalı');
+        } else {
+            console.log('\n⚠️  Sistem sesi cihazı yok');
+            console.log('💡 BlackHole veya Soundflower yüklemen gerekiyor');
+        }
+        
+        // Kısa test kayıt
+        console.log('\n🔴 2 saniyelik test kayıt başlıyor...');
+        console.log('🎵 Şimdi müzik çal!');
+        
+        await recorder.startRecording('./test-output/quick-test.mov', {
+            includeSystemAudio: true,
+            includeMicrophone: false,
+            systemAudioDeviceId: sysDevice?.id,
+            captureArea: { x: 0, y: 0, width: 200, height: 150 }
+        });
+        
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        await recorder.stopRecording();
+        
+        console.log('✅ Test tamamlandı! ./test-output/quick-test.mov dosyasını kontrol et');
+        
+    } catch (error) {
+        console.error('❌ Hata:', error.message);
+    }
+}
+
+quickTest();

package/simple-api-example.js

@@ -0,0 +1,182 @@
+// ===== SENİN UYGULAMANDA NASIL KULLANACAĞIN =====
+
+const MacRecorder = require('node-mac-recorder'); // npm install node-mac-recorder
+
+async function myAppRecording() {
+    const recorder = new MacRecorder();
+    
+    // === 1. KULLANICIYA SES CİHAZLARINI GÖSTER ===
+    const devices = await recorder.getAudioDevices();
+    console.log('🎤 Ses cihazları:');
+    devices.forEach((d, i) => console.log(`${i+1}. ${d.name}`));
+    
+    // === 2. SİSTEM SESİ CİHAZINI BUL ===
+    const systemDevice = devices.find(d => 
+        d.name.includes('Aggregate') || 
+        d.name.includes('iMobie') ||
+        d.name.includes('BlackHole')
+    );
+    
+    if (!systemDevice) {
+        console.log('⚠️ Sistem ses cihazı yok. Sadece mikrofon kullanılacak.');
+    }
+    
+    // === 3. KULLANICI TERCİHLERİ ===
+    const userPrefs = {
+        recordSystemAudio: true,     // Kullanıcının sistem sesi tercihi
+        recordMicrophone: false,     // Kullanıcının mikrofon tercihi
+        outputPath: './my-recording.mov'
+    };
+    
+    // === 4. KAYIT BAŞLAT ===
+    const options = {
+        // Sistem sesi
+        includeSystemAudio: userPrefs.recordSystemAudio,
+        systemAudioDeviceId: systemDevice?.id, // Bulunan cihazı kullan
+        
+        // Mikrofon
+        includeMicrophone: userPrefs.recordMicrophone,
+        
+        // Diğer seçenekler
+        captureCursor: true,
+        quality: 'high'
+    };
+    
+    console.log('🔴 Kayıt başlıyor...', options);
+    await recorder.startRecording(userPrefs.outputPath, options);
+    
+    // === 5. KAYDI DURDUR ===
+    setTimeout(async () => {
+        await recorder.stopRecording();
+        console.log('✅ Kayıt bitti:', userPrefs.outputPath);
+    }, 5000);
+}
+
+// === ELECTRONʼDA KULLANIM ===
+// main.js
+const { ipcMain } = require('electron');
+const MacRecorder = require('node-mac-recorder');
+
+const recorder = new MacRecorder();
+
+// Renderer'dan gelen istekleri dinle
+ipcMain.handle('get-audio-devices', async () => {
+    return await recorder.getAudioDevices();
+});
+
+ipcMain.handle('start-recording', async (event, options) => {
+    try {
+        await recorder.startRecording('./recording.mov', {
+            includeSystemAudio: options.systemAudio,  // true/false
+            includeMicrophone: options.microphone,    // true/false
+            systemAudioDeviceId: options.systemDeviceId || null
+        });
+        return { success: true };
+    } catch (error) {
+        return { success: false, error: error.message };
+    }
+});
+
+ipcMain.handle('stop-recording', async () => {
+    return await recorder.stopRecording();
+});
+
+// === REACTʼTE KULLANIM ===
+// renderer.js veya React component
+const { ipcRenderer } = require('electron');
+
+class RecordingComponent {
+    async componentDidMount() {
+        // Ses cihazlarını al
+        this.audioDevices = await ipcRenderer.invoke('get-audio-devices');
+        this.setState({ audioDevices: this.audioDevices });
+    }
+    
+    async startRecording() {
+        const options = {
+            systemAudio: this.state.enableSystemAudio,    // checkbox değeri
+            microphone: this.state.enableMicrophone,      // checkbox değeri
+            systemDeviceId: this.state.selectedSystemDevice // dropdown değeri
+        };
+        
+        const result = await ipcRenderer.invoke('start-recording', options);
+        if (result.success) {
+            this.setState({ recording: true });
+        }
+    }
+    
+    async stopRecording() {
+        await ipcRenderer.invoke('stop-recording');
+        this.setState({ recording: false });
+    }
+    
+    render() {
+        return (
+            <div>
+                <label>
+                    <input 
+                        type="checkbox" 
+                        checked={this.state.enableSystemAudio}
+                        onChange={e => this.setState({enableSystemAudio: e.target.checked})}
+                    />
+                    Sistem Sesini Kaydet
+                </label>
+                
+                <select onChange={e => this.setState({selectedSystemDevice: e.target.value})}>
+                    {this.state.audioDevices?.map(device => (
+                        <option key={device.id} value={device.id}>
+                            {device.name}
+                        </option>
+                    ))}
+                </select>
+                
+                <button onClick={() => this.startRecording()}>
+                    Kayıt Başlat
+                </button>
+            </div>
+        );
+    }
+}
+
+// === EXPRESS API ===
+const express = require('express');
+const MacRecorder = require('node-mac-recorder');
+
+const app = express();
+const recorder = new MacRecorder();
+
+app.use(express.json());
+
+// Ses cihazlarını listele
+app.get('/api/audio-devices', async (req, res) => {
+    const devices = await recorder.getAudioDevices();
+    res.json(devices);
+});
+
+// Kayıt başlat
+app.post('/api/start-recording', async (req, res) => {
+    const { systemAudio, microphone, systemDeviceId } = req.body;
+    
+    try {
+        await recorder.startRecording('./api-recording.mov', {
+            includeSystemAudio: systemAudio,     // true/false
+            includeMicrophone: microphone,       // true/false
+            systemAudioDeviceId: systemDeviceId || null
+        });
+        
+        res.json({ success: true, message: 'Recording started' });
+    } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+    }
+});
+
+// Kayıt durdur
+app.post('/api/stop-recording', async (req, res) => {
+    const result = await recorder.stopRecording();
+    res.json(result);
+});
+
+// Test et
+if (require.main === module) {
+    myAppRecording().catch(console.error);
+}

package/src/mac_recorder.mm

@@ -71,6 +71,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     bool includeSystemAudio = true; // Default olarak sistem sesi açık
     CGDirectDisplayID displayID = CGMainDisplayID(); // Default ana ekran
     NSString *audioDeviceId = nil; // Default audio device ID
+    NSString *systemAudioDeviceId = nil; // System audio device ID
     
     if (info.Length() > 1 && info[1].IsObject()) {
         Napi::Object options = info[1].As<Napi::Object>();
@@ -109,20 +110,40 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             includeSystemAudio = options.Get("includeSystemAudio").As<Napi::Boolean>();
         }
         
+        // System audio device ID
+        if (options.Has("systemAudioDeviceId") && !options.Get("systemAudioDeviceId").IsNull()) {
+            std::string sysDeviceId = options.Get("systemAudioDeviceId").As<Napi::String>().Utf8Value();
+            systemAudioDeviceId = [NSString stringWithUTF8String:sysDeviceId.c_str()];
+        }
+        
         // Display ID
         if (options.Has("displayId") && !options.Get("displayId").IsNull()) {
             double displayIdNum = options.Get("displayId").As<Napi::Number>().DoubleValue();
             
-            // Get all displays and use the specified one
+            // Use the display ID directly (not as an index)
+            // The JavaScript layer passes the actual CGDirectDisplayID
+            displayID = (CGDirectDisplayID)displayIdNum;
+            
+            // Verify that this display ID is valid
             uint32_t displayCount;
             CGGetActiveDisplayList(0, NULL, &displayCount);
             if (displayCount > 0) {
                 CGDirectDisplayID *displays = (CGDirectDisplayID*)malloc(displayCount * sizeof(CGDirectDisplayID));
                 CGGetActiveDisplayList(displayCount, displays, &displayCount);
                 
-                if (displayIdNum >= 0 && displayIdNum < displayCount) {
-                    displayID = displays[(int)displayIdNum];
+                bool validDisplay = false;
+                for (uint32_t i = 0; i < displayCount; i++) {
+                    if (displays[i] == displayID) {
+                        validDisplay = true;
+                        break;
+                    }
                 }
+                
+                if (!validDisplay) {
+                    // Fallback to main display if invalid ID provided
+                    displayID = CGMainDisplayID();
+                }
+                
                 free(displays);
             }
         }
@@ -200,11 +221,71 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             }
         }
         
-        // System audio için AVCaptureScreenInput zaten sistem sesini yakalar
-        // includeSystemAudio parametresi screen input'un ses yakalama özelliğini kontrol eder
+        // System audio configuration
         if (includeSystemAudio) {
+            // Enable audio capture in screen input
             g_screenInput.capturesMouseClicks = YES;
-            // AVCaptureScreenInput otomatik olarak sistem sesini yakalar
+            
+            // Try to add system audio input using Core Audio
+            // This approach captures system audio by creating a virtual audio device
+            if (@available(macOS 10.15, *)) {
+                // Configure screen input for better audio capture
+                g_screenInput.capturesCursor = captureCursor;
+                g_screenInput.capturesMouseClicks = YES;
+                
+                // Try to find and add system audio device (like Soundflower, BlackHole, etc.)
+                NSArray *audioDevices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeAudio];
+                AVCaptureDevice *systemAudioDevice = nil;
+                
+                // If specific system audio device ID is provided, try to find it first
+                if (systemAudioDeviceId) {
+                    for (AVCaptureDevice *device in audioDevices) {
+                        if ([device.uniqueID isEqualToString:systemAudioDeviceId]) {
+                            systemAudioDevice = device;
+                            NSLog(@"[DEBUG] Found specified system audio device: %@ (ID: %@)", device.localizedName, device.uniqueID);
+                            break;
+                        }
+                    }
+                }
+                
+                // If no specific device found or specified, look for known system audio devices
+                if (!systemAudioDevice) {
+                    for (AVCaptureDevice *device in audioDevices) {
+                        NSString *deviceName = [device.localizedName lowercaseString];
+                        // Check for common system audio capture devices
+                        if ([deviceName containsString:@"soundflower"] || 
+                            [deviceName containsString:@"blackhole"] ||
+                            [deviceName containsString:@"loopback"] ||
+                            [deviceName containsString:@"system audio"] ||
+                            [deviceName containsString:@"aggregate"]) {
+                            systemAudioDevice = device;
+                            NSLog(@"[DEBUG] Auto-detected system audio device: %@", device.localizedName);
+                            break;
+                        }
+                    }
+                }
+                
+                // If we found a system audio device, add it as an additional input
+                if (systemAudioDevice && !includeMicrophone) {
+                    // Only add system audio device if microphone is not already added
+                    NSError *error;
+                    AVCaptureDeviceInput *systemAudioInput = [[AVCaptureDeviceInput alloc] initWithDevice:systemAudioDevice error:&error];
+                    if (systemAudioInput && [g_captureSession canAddInput:systemAudioInput]) {
+                        [g_captureSession addInput:systemAudioInput];
+                        NSLog(@"[DEBUG] Successfully added system audio device: %@", systemAudioDevice.localizedName);
+                    } else if (error) {
+                        NSLog(@"[DEBUG] Failed to add system audio device: %@", error.localizedDescription);
+                    }
+                } else if (includeSystemAudio && !systemAudioDevice) {
+                    NSLog(@"[DEBUG] System audio requested but no suitable device found. Available devices:");
+                    for (AVCaptureDevice *device in audioDevices) {
+                        NSLog(@"[DEBUG] - %@ (ID: %@)", device.localizedName, device.uniqueID);
+                    }
+                }
+            }
+        } else {
+            // Explicitly disable audio capture if not requested
+            g_screenInput.capturesMouseClicks = NO;
         }
         
         // Create movie file output

package/src/screen_capture_kit.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+#import <ScreenCaptureKit/ScreenCaptureKit.h>
+#import <AVFoundation/AVFoundation.h>
+
+API_AVAILABLE(macos(12.3))
+@interface ScreenCaptureKitRecorder : NSObject
+
++ (BOOL)isScreenCaptureKitAvailable;
++ (BOOL)startRecordingWithConfiguration:(NSDictionary *)config 
+                               delegate:(id)delegate 
+                                  error:(NSError **)error;
++ (void)stopRecording;
++ (BOOL)isRecording;
+
+@end

package/system-sound-test.js

@@ -0,0 +1,46 @@
+const MacRecorder = require('./index');
+
+async function testWithSystemSound() {
+    const recorder = new MacRecorder();
+    
+    console.log('🎵 SİSTEM SESİ TEST EDİLİYOR\n');
+    console.log('📋 ÖNEMLİ: Bu testi yapmadan önce:');
+    console.log('1. System Preferences > Sound > Output');
+    console.log('2. "iMobie Speaker" veya "iMobie Aggregate Device" seç');
+    console.log('3. Müzik çalabildiğini kontrol et');
+    console.log('');
+    console.log('⏳ 5 saniye bekleniyor, hazırlık yap...');
+    
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    
+    try {
+        console.log('🔴 KAYIT BAŞLIYOR (3 saniye)...');
+        console.log('🎵 ŞİMDİ MÜZİK ÇAL veya YouTube video aç!');
+        
+        await recorder.startRecording('./test-output/system-sound-test.mov', {
+            includeSystemAudio: true,
+            includeMicrophone: false,
+            systemAudioDeviceId: 'iMobie_AggregateDevice_UID', // Direkt ID kullan
+            captureArea: { x: 0, y: 0, width: 400, height: 300 }
+        });
+        
+        // 3 saniye kayıt
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        
+        await recorder.stopRecording();
+        console.log('✅ KAYIT TAMAMLANDI!');
+        console.log('📁 Dosya: ./test-output/system-sound-test.mov');
+        
+        // Dosyayı aç
+        console.log('🔍 Dosya açılıyor...');
+        require('child_process').exec('open ./test-output/system-sound-test.mov');
+        
+        console.log('\n✅ Eğer ses duyuyorsan: SİSTEM SESİ ÇALIŞIYOR! 🎉');
+        console.log('❌ Eğer ses yoksa: Sistem ses output\'unu iMobie cihazına ayarla');
+        
+    } catch (error) {
+        console.error('❌ Test hatası:', error.message);
+    }
+}
+
+testWithSystemSound();

package/test-system-audio.js

@@ -0,0 +1,104 @@
+const MacRecorder = require('./index');
+const path = require('path');
+
+async function testSystemAudio() {
+    const recorder = new MacRecorder();
+    
+    console.log('🎵 Sistem Sesi Yakalama Testi Başlıyor...\n');
+    
+    try {
+        // Önce izinleri kontrol et
+        const permissions = await recorder.checkPermissions();
+        console.log('📋 İzinler:', permissions);
+        
+        if (!permissions.screenRecording) {
+            console.log('❌ Ekran kayıt izni gerekli. System Preferences > Security & Privacy > Screen Recording');
+            return;
+        }
+        
+        // Mevcut ses cihazlarını listele
+        console.log('\n🎤 Mevcut Ses Cihazları:');
+        const audioDevices = await recorder.getAudioDevices();
+        audioDevices.forEach((device, index) => {
+            console.log(`${index + 1}. ${device.name}`);
+            if (device.id) console.log(`   ID: ${device.id}`);
+        });
+        
+        // Sistem sesi cihazı ara
+        const systemAudioDevice = audioDevices.find(device => 
+            device.name.toLowerCase().includes('blackhole') ||
+            device.name.toLowerCase().includes('soundflower') ||
+            device.name.toLowerCase().includes('loopback') ||
+            device.name.toLowerCase().includes('aggregate') ||
+            device.name.toLowerCase().includes('imobie')
+        );
+        
+        console.log('\n=== Test 1: Sistem Sesi KAPALI ===');
+        const outputPath1 = path.join(__dirname, 'test-output', 'no-system-audio.mov');
+        
+        await recorder.startRecording(outputPath1, {
+            includeSystemAudio: false, // Sistem sesi kapalı
+            includeMicrophone: false,
+            captureCursor: true,
+            captureArea: { x: 0, y: 0, width: 400, height: 300 } // Küçük alan
+        });
+        
+        console.log('🔴 5 saniye kayıt yapılıyor (sistem sesi KAPALI)...');
+        console.log('💡 Şimdi müzik çal veya YouTube video aç - ses KAYIT EDİLMEMELİ');
+        
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        await recorder.stopRecording();
+        console.log(`✅ Kayıt tamamlandı: ${outputPath1}`);
+        
+        // 2 saniye bekle
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        console.log('\n=== Test 2: Sistem Sesi AÇIK ===');
+        const outputPath2 = path.join(__dirname, 'test-output', 'with-system-audio.mov');
+        
+        const options2 = {
+            includeSystemAudio: true, // Sistem sesi açık
+            includeMicrophone: false,
+            captureCursor: true,
+            captureArea: { x: 0, y: 0, width: 400, height: 300 }
+        };
+        
+        // Eğer sistem sesi cihazı varsa onu kullan
+        if (systemAudioDevice) {
+            options2.systemAudioDeviceId = systemAudioDevice.id;
+            console.log(`🎯 Kullanılan sistem sesi cihazı: ${systemAudioDevice.name}`);
+        }
+        
+        await recorder.startRecording(outputPath2, options2);
+        
+        console.log('🔴 5 saniye kayıt yapılıyor (sistem sesi AÇIK)...');
+        console.log('🎵 Şimdi müzik çal veya YouTube video aç - ses KAYIT EDİLMELİ');
+        
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        await recorder.stopRecording();
+        console.log(`✅ Kayıt tamamlandı: ${outputPath2}`);
+        
+        console.log('\n=== 🎉 TEST TAMAMLANDI ===');
+        console.log('📁 Kayıtları karşılaştır:');
+        console.log(`1. ${outputPath1} (sistem sesi YOK)`);
+        console.log(`2. ${outputPath2} (sistem sesi VAR)`);
+        
+        if (!systemAudioDevice) {
+            console.log('\n⚠️  Sistem sesi cihazı bulunamadı!');
+            console.log('💡 Daha iyi sistem sesi yakalama için şunları yükle:');
+            console.log('   • BlackHole: https://github.com/ExistentialAudio/BlackHole');
+            console.log('   • Soundflower: https://github.com/mattingalls/Soundflower');
+        }
+        
+        console.log('\n🔍 Kayıtları test etmek için:');
+        console.log('1. Dosyaları QuickTime Player ile aç');
+        console.log('2. İlk kayıtta ses olmamalı');
+        console.log('3. İkinci kayıtta sistem sesi olmalı');
+        
+    } catch (error) {
+        console.error('❌ Test hatası:', error.message);
+    }
+}
+
+// Testi çalıştır
+testSystemAudio();

package/usage-examples.js

@@ -0,0 +1,202 @@
+const MacRecorder = require('./index');
+
+// ===== PARAMETRIK KULLANIM ÖRNEKLERİ =====
+
+async function examples() {
+    const recorder = new MacRecorder();
+    
+    console.log('🎯 PARAMETRİK SİSTEM SESİ KULLANIMI\n');
+    
+    // 1. SİSTEM SESİ AÇIK (default)
+    console.log('1️⃣ Sistem sesi AÇIK (default):');
+    await recorder.startRecording('./output1.mov', {
+        includeSystemAudio: true,        // Default zaten true
+        includeMicrophone: false
+    });
+    // ... kayıt yap ve durdur
+    
+    // 2. SİSTEM SESİ KAPALI
+    console.log('2️⃣ Sistem sesi KAPALI:');
+    await recorder.startRecording('./output2.mov', {
+        includeSystemAudio: false,       // Açıkça kapat
+        includeMicrophone: true          // Sadece mikrofon
+    });
+    
+    // 3. BELİRLİ SES CİHAZI İLE
+    console.log('3️⃣ Belirli sistem ses cihazı:');
+    
+    // Önce cihazları listele
+    const devices = await recorder.getAudioDevices();
+    const systemDevice = devices.find(d => 
+        d.name.includes('iMobie') || 
+        d.name.includes('BlackHole') ||
+        d.name.includes('Aggregate')
+    );
+    
+    if (systemDevice) {
+        await recorder.startRecording('./output3.mov', {
+            includeSystemAudio: true,
+            systemAudioDeviceId: systemDevice.id,  // Belirli cihaz
+            includeMicrophone: false
+        });
+    }
+    
+    // 4. HER İKİSİ BİRDEN
+    console.log('4️⃣ Sistem sesi + Mikrofon:');
+    await recorder.startRecording('./output4.mov', {
+        includeSystemAudio: true,        // Sistem sesi
+        includeMicrophone: true,         // Mikrofon
+        audioDeviceId: 'BuiltInMicrophoneDevice', // Mikrofon cihazı
+        systemAudioDeviceId: systemDevice?.id     // Sistem ses cihazı
+    });
+    
+    console.log('✅ Tüm örnekler hazır!');
+}
+
+// BAŞKA UYGULAMADA KULLANIM
+async function usageInYourApp() {
+    const recorder = new MacRecorder();
+    
+    // ===== SENİN UYGULAMANLA ENTEGRASYON =====
+    
+    // Kullanıcı ayarları
+    const userSettings = {
+        captureSystemAudio: true,        // Kullanıcının seçimi
+        captureMicrophone: false,        // Kullanıcının seçimi
+        preferredSystemAudioDevice: null // Kullanıcının seçtiği cihaz
+    };
+    
+    // Cihazları al ve kullanıcıya göster
+    const audioDevices = await recorder.getAudioDevices();
+    const systemAudioDevices = audioDevices.filter(device => 
+        device.name.toLowerCase().includes('aggregate') ||
+        device.name.toLowerCase().includes('blackhole') ||
+        device.name.toLowerCase().includes('soundflower') ||
+        device.name.toLowerCase().includes('imobie')
+    );
+    
+    console.log('🎤 Sistem ses cihazları:');
+    systemAudioDevices.forEach((device, i) => {
+        console.log(`${i + 1}. ${device.name}`);
+    });
+    
+    // Kayıt başlat
+    const recordingOptions = {
+        includeSystemAudio: userSettings.captureSystemAudio,
+        includeMicrophone: userSettings.captureMicrophone,
+    };
+    
+    // Eğer kullanıcı belirli cihaz seçtiyse
+    if (userSettings.preferredSystemAudioDevice) {
+        recordingOptions.systemAudioDeviceId = userSettings.preferredSystemAudioDevice;
+    }
+    
+    // Kayıt başlat
+    await recorder.startRecording('./user-recording.mov', recordingOptions);
+    
+    console.log('🔴 Kayıt başladı...');
+    
+    // Gerektiğinde durdur
+    setTimeout(async () => {
+        await recorder.stopRecording();
+        console.log('✅ Kayıt bitti!');
+    }, 5000);
+}
+
+// ===== REACT/ELECTRON ÖRNEĞİ =====
+class AudioRecorderService {
+    constructor() {
+        this.recorder = new MacRecorder();
+        this.isRecording = false;
+    }
+    
+    async getAvailableSystemAudioDevices() {
+        const devices = await this.recorder.getAudioDevices();
+        return devices.filter(device => 
+            device.name.toLowerCase().includes('aggregate') ||
+            device.name.toLowerCase().includes('blackhole') ||
+            device.name.toLowerCase().includes('imobie')
+        );
+    }
+    
+    async startRecording(options = {}) {
+        const {
+            outputPath,
+            includeSystemAudio = true,      // Default açık
+            includeMicrophone = false,
+            systemAudioDeviceId = null,
+            audioDeviceId = null,
+            windowId = null,
+            displayId = null
+        } = options;
+        
+        if (this.isRecording) {
+            throw new Error('Already recording');
+        }
+        
+        const recordingConfig = {
+            includeSystemAudio,
+            includeMicrophone,
+            systemAudioDeviceId,
+            audioDeviceId,
+            windowId,
+            displayId
+        };
+        
+        await this.recorder.startRecording(outputPath, recordingConfig);
+        this.isRecording = true;
+        
+        return { success: true, config: recordingConfig };
+    }
+    
+    async stopRecording() {
+        if (!this.isRecording) {
+            throw new Error('Not recording');
+        }
+        
+        const result = await this.recorder.stopRecording();
+        this.isRecording = false;
+        
+        return result;
+    }
+    
+    getRecordingStatus() {
+        return {
+            isRecording: this.isRecording,
+            ...this.recorder.getStatus()
+        };
+    }
+}
+
+// KULLANIM ÖRNEĞİ
+async function exampleUsage() {
+    const service = new AudioRecorderService();
+    
+    // Sistem ses cihazlarını listele
+    const systemDevices = await service.getAvailableSystemAudioDevices();
+    console.log('Mevcut sistem ses cihazları:', systemDevices);
+    
+    // Kayıt başlat - sistem sesi açık
+    await service.startRecording({
+        outputPath: './my-app-recording.mov',
+        includeSystemAudio: true,           // ✅ Sistem sesi
+        includeMicrophone: false,           // ❌ Mikrofon
+        systemAudioDeviceId: systemDevices[0]?.id  // İlk cihazı kullan
+    });
+    
+    console.log('Recording started with system audio!');
+    
+    // 10 saniye sonra durdur
+    setTimeout(async () => {
+        await service.stopRecording();
+        console.log('Recording finished!');
+    }, 10000);
+}
+
+// Test et
+if (require.main === module) {
+    console.log('🚀 Parametrik sistem sesi test ediliyor...\n');
+    exampleUsage().catch(console.error);
+}
+
+module.exports = { AudioRecorderService };