node-mac-recorder 2.1.2 → 2.2.1

package/test-audio.js

@@ -0,0 +1,94 @@
+const MacRecorder = require('./index');
+
+function testAudioCapture() {
+    console.log('🎵 Testing ScreenCaptureKit Audio Capture...\n');
+    
+    const recorder = new MacRecorder();
+    let testCompleted = false;
+    
+    // Set timeout to prevent hanging
+    setTimeout(() => {
+        if (!testCompleted) {
+            console.log('⚠️ Test timed out after 10 seconds');
+            process.exit(0);
+        }
+    }, 10000);
+    
+    try {
+        console.log('📱 Testing audio device enumeration...');
+        
+        // Test audio device enumeration - this should work without permissions
+        const startTime = Date.now();
+        
+        recorder.getAudioDevices((err, audioDevices) => {
+            const elapsed = Date.now() - startTime;
+            console.log(`⏱️  getAudioDevices took ${elapsed}ms`);
+            
+            if (err) {
+                console.error('❌ getAudioDevices failed:', err);
+                testCompleted = true;
+                return;
+            }
+            
+            console.log(`✅ Found ${audioDevices.length} audio devices:`);
+            
+            audioDevices.slice(0, 5).forEach((device, index) => {
+                console.log(`${index + 1}. "${device.name}" (${device.manufacturer || 'Unknown'})`);
+                console.log(`   ID: ${device.id}`);
+                console.log(`   Default: ${device.isDefault ? 'Yes' : 'No'}`);
+                if (device.isSystemDevice) {
+                    console.log(`   System Device: ${device.isSystemDevice ? 'Yes' : 'No'}`);
+                }
+                console.log('');
+            });
+            
+            // Test permissions
+            console.log('🔐 Testing audio permissions...');
+            
+            recorder.checkPermissions((err, hasPermissions) => {
+                const elapsed2 = Date.now() - startTime;
+                console.log(`⏱️  checkPermissions took ${elapsed2 - elapsed}ms`);
+                
+                if (err) {
+                    console.error('❌ checkPermissions failed:', err);
+                } else {
+                    console.log(`✅ Permissions status: ${hasPermissions ? 'Granted' : 'Not granted'}`);
+                }
+                
+                // Test microphone-specific features if available
+                if (audioDevices.length > 0) {
+                    const micDevice = audioDevices.find(d => d.isDefault && !d.isSystemDevice);
+                    const systemDevice = audioDevices.find(d => d.isSystemDevice);
+                    
+                    if (micDevice) {
+                        console.log(`🎤 Default microphone: "${micDevice.name}"`);
+                        console.log(`   This would be used for includeMicrophone: true`);
+                    }
+                    
+                    if (systemDevice) {
+                        console.log(`🔊 System audio device found: "${systemDevice.name}"`);
+                        console.log(`   This would be used for includeSystemAudio: true`);
+                    } else {
+                        console.log('⚠️ No system audio device detected');
+                        console.log('   For system audio capture, consider installing BlackHole or similar');
+                    }
+                }
+                
+                console.log('\n✅ Audio capture tests completed successfully!');
+                console.log('\n📝 Audio Configuration Summary:');
+                console.log(`   • Total audio devices: ${audioDevices.length}`);
+                console.log(`   • Microphone devices: ${audioDevices.filter(d => !d.isSystemDevice).length}`);
+                console.log(`   • System audio devices: ${audioDevices.filter(d => d.isSystemDevice).length}`);
+                console.log(`   • Permissions: ${hasPermissions ? '✅ Granted' : '❌ Need to grant'}`);
+                
+                testCompleted = true;
+            });
+        });
+        
+    } catch (error) {
+        console.error('❌ Audio capture test failed:', error);
+        testCompleted = true;
+    }
+}
+
+testAudioCapture();

package/test-comprehensive.js

@@ -0,0 +1,164 @@
+const MacRecorder = require('./index');
+const fs = require('fs');
+const path = require('path');
+
+function runComprehensiveTests() {
+    console.log('🧪 Running Comprehensive ScreenCaptureKit Tests\n');
+    console.log('=' .repeat(60));
+    
+    const recorder = new MacRecorder();
+    let testResults = {
+        passed: 0,
+        failed: 0,
+        details: []
+    };
+    
+    function addResult(testName, passed, details = '') {
+        testResults.details.push({
+            name: testName,
+            passed,
+            details
+        });
+        
+        if (passed) {
+            testResults.passed++;
+            console.log(`✅ ${testName}`);
+        } else {
+            testResults.failed++;
+            console.log(`❌ ${testName}: ${details}`);
+        }
+        if (details && passed) {
+            console.log(`   ${details}`);
+        }
+    }
+    
+    // Test 1: Module Loading
+    try {
+        addResult('Module Loading', true, 'MacRecorder class instantiated successfully');
+    } catch (error) {
+        addResult('Module Loading', false, error.message);
+    }
+    
+    // Test 2: Method Availability
+    const expectedMethods = [
+        'getDisplays', 'getWindows', 'getAudioDevices', 'startRecording', 
+        'stopRecording', 'checkPermissions', 'getCursorPosition',
+        'getWindowThumbnail', 'getDisplayThumbnail'
+    ];
+    
+    let missingMethods = [];
+    expectedMethods.forEach(method => {
+        if (typeof recorder[method] !== 'function') {
+            missingMethods.push(method);
+        }
+    });
+    
+    if (missingMethods.length === 0) {
+        addResult('API Method Availability', true, `All ${expectedMethods.length} expected methods available`);
+    } else {
+        addResult('API Method Availability', false, `Missing methods: ${missingMethods.join(', ')}`);
+    }
+    
+    // Test 3: Synchronous Operations
+    try {
+        const cursor = recorder.getCurrentCursorPosition();
+        if (cursor && typeof cursor.x === 'number' && typeof cursor.y === 'number') {
+            addResult('Cursor Position (Sync)', true, `Position: (${cursor.x}, ${cursor.y}), Type: ${cursor.cursorType}`);
+        } else {
+            addResult('Cursor Position (Sync)', false, 'Invalid cursor data returned');
+        }
+    } catch (error) {
+        addResult('Cursor Position (Sync)', false, error.message);
+    }
+    
+    // Test 4: Cursor Capture Status
+    try {
+        const status = recorder.getCursorCaptureStatus();
+        addResult('Cursor Capture Status', true, `Tracking: ${status.isTracking || false}`);
+    } catch (error) {
+        addResult('Cursor Capture Status', false, error.message);
+    }
+    
+    console.log('\n' + '─'.repeat(60));
+    console.log('📊 Test Results Summary:');
+    console.log('─'.repeat(60));
+    console.log(`✅ Passed: ${testResults.passed}`);
+    console.log(`❌ Failed: ${testResults.failed}`);
+    console.log(`📈 Success Rate: ${Math.round((testResults.passed / (testResults.passed + testResults.failed)) * 100)}%`);
+    
+    console.log('\n🔍 Detailed Analysis:');
+    console.log('─'.repeat(60));
+    
+    // Test async operations with timeout
+    console.log('\n🔄 Testing Async Operations (with 8s timeout each):');
+    
+    let asyncTests = 0;
+    let asyncPassed = 0;
+    
+    function testAsync(testName, asyncFunction, timeout = 8000) {
+        return new Promise((resolve) => {
+            asyncTests++;
+            const timeoutId = setTimeout(() => {
+                console.log(`⚠️  ${testName}: Timed out after ${timeout/1000}s (likely permission dialog)`);
+                resolve(false);
+            }, timeout);
+            
+            try {
+                asyncFunction((error, result) => {
+                    clearTimeout(timeoutId);
+                    if (error) {
+                        console.log(`❌ ${testName}: ${error.message || error}`);
+                        resolve(false);
+                    } else {
+                        const resultInfo = Array.isArray(result) ? `${result.length} items` : 'Success';
+                        console.log(`✅ ${testName}: ${resultInfo}`);
+                        asyncPassed++;
+                        resolve(true);
+                    }
+                });
+            } catch (error) {
+                clearTimeout(timeoutId);
+                console.log(`❌ ${testName}: ${error.message}`);
+                resolve(false);
+            }
+        });
+    }
+    
+    // Run async tests sequentially
+    (async () => {
+        await testAsync('Permissions Check', (cb) => recorder.checkPermissions(cb));
+        await testAsync('Display Enumeration', (cb) => recorder.getDisplays(cb));
+        await testAsync('Window Enumeration', (cb) => recorder.getWindows(cb));
+        await testAsync('Audio Device Enumeration', (cb) => recorder.getAudioDevices(cb));
+        
+        console.log('\n' + '═'.repeat(60));
+        console.log('🏁 Final Test Summary:');
+        console.log('═'.repeat(60));
+        console.log(`🔧 Synchronous Tests: ${testResults.passed}/${testResults.passed + testResults.failed} passed`);
+        console.log(`🔄 Asynchronous Tests: ${asyncPassed}/${asyncTests} passed`);
+        console.log(`📊 Overall: ${testResults.passed + asyncPassed}/${testResults.passed + testResults.failed + asyncTests} tests passed`);
+        
+        const overallSuccess = Math.round(((testResults.passed + asyncPassed) / (testResults.passed + testResults.failed + asyncTests)) * 100);
+        
+        if (overallSuccess >= 80) {
+            console.log(`\n🎉 ScreenCaptureKit Migration: ${overallSuccess}% SUCCESS!`);
+            console.log('✨ The migration is working correctly');
+        } else if (overallSuccess >= 60) {
+            console.log(`\n⚠️  ScreenCaptureKit Migration: ${overallSuccess}% PARTIAL SUCCESS`);
+            console.log('🔧 Some functionality working, permissions may need attention');
+        } else {
+            console.log(`\n❌ ScreenCaptureKit Migration: ${overallSuccess}% - NEEDS WORK`);
+            console.log('🚨 Multiple issues detected');
+        }
+        
+        console.log('\n💡 Notes:');
+        console.log('• Timeouts usually indicate missing screen recording permissions');
+        console.log('• Enable permissions in: System Preferences > Privacy & Security > Screen Recording');
+        console.log('• ScreenCaptureKit requires macOS 12.3+ and arm64 architecture');
+        console.log('• All synchronous operations (cursor tracking) should work without permissions');
+        
+        process.exit(0);
+    })();
+}
+
+runComprehensiveTests();

package/test-recording.js

@@ -0,0 +1,142 @@
+const MacRecorder = require("./index");
+const path = require("path");
+const fs = require("fs");
+
+async function testRecording() {
+	console.log("🎬 Testing ScreenCaptureKit Recording...\n");
+
+	const recorder = new MacRecorder();
+	const outputDir = path.join(__dirname, "test-output");
+
+	// Create test output directory
+	if (!fs.existsSync(outputDir)) {
+		fs.mkdirSync(outputDir);
+		console.log("📁 Created test-output directory");
+	}
+
+	const outputFile = path.resolve(outputDir, "sck-test-recording.mov");
+	console.log(`📹 Output file: ${outputFile}`);
+
+	// Test recording options
+	const recordingOptions = {
+		captureCursor: true,
+		excludeCurrentApp: true,
+		includeMicrophone: true,
+		includeSystemAudio: true, // Disable to avoid permission issues for now
+		displayId: null, // Will use main display
+	};
+
+	console.log(
+		"📝 Recording options:",
+		JSON.stringify(recordingOptions, null, 2)
+	);
+	console.log("\n🚀 Starting recording test...");
+
+	try {
+		// Test current cursor position before recording
+		const cursor = recorder.getCurrentCursorPosition();
+		console.log(
+			`🖱️  Current cursor: x=${cursor.x}, y=${cursor.y}, type=${cursor.cursorType}`
+		);
+
+		// Determine a window to exclude (prefer a window with name containing "Cursor")
+		try {
+			const windows = await recorder.getWindows();
+			if (Array.isArray(windows) && windows.length) {
+				const pick =
+					windows.find(
+						(w) =>
+							(typeof w.appName === "string" && /cursor/i.test(w.appName)) ||
+							(typeof w.name === "string" && /cursor/i.test(w.name)) ||
+							(typeof w.title === "string" && /cursor/i.test(w.title))
+					) || windows[0];
+				const wid = pick?.id ?? pick?.windowId ?? pick?.windowID ?? null;
+				if (wid != null) {
+					recordingOptions.excludeWindowIds = [Number(wid)];
+				}
+			}
+		} catch (_) {}
+
+		// Start recording
+		console.log("▶️  Attempting to start recording...");
+
+		// Start recording without callback first
+		console.log("🔍 Attempting startRecording without callback...");
+
+		let startResult;
+		try {
+			startResult = await recorder.startRecording(outputFile, recordingOptions);
+			console.log(`📊 startRecording resolved: ${startResult}`);
+		} catch (error) {
+			console.error("❌ startRecording threw error:", error.message);
+			console.error("Stack:", error.stack);
+			return;
+		}
+
+		if (startResult) {
+			console.log("✅ Recording started successfully");
+			console.log("⏱️  Recording for 3 seconds...");
+
+			// Record for ~6 seconds
+			setTimeout(async () => {
+				console.log("⏹️  Stopping recording...");
+
+				let stopResult;
+				try {
+					stopResult = await recorder.stopRecording();
+					console.log(
+						`📊 stopRecording resolved: ${JSON.stringify(stopResult)}`
+					);
+
+					if (stopResult && stopResult.code === 0) {
+						console.log("✅ Stop recording command sent");
+					} else {
+						console.log("❌ Failed to send stop recording command");
+					}
+				} catch (error) {
+					console.error("❌ stopRecording threw error:", error.message);
+					console.error("Stack:", error.stack);
+				}
+
+				// Final check after a longer delay
+				setTimeout(() => {
+					console.log("\n📊 Final Results:");
+
+					try {
+						if (fs.existsSync(outputFile)) {
+							const stats = fs.statSync(outputFile);
+							console.log(`✅ Recording file exists: ${stats.size} bytes`);
+							console.log(`📁 Location: ${outputFile}`);
+							console.log("🎯 ScreenCaptureKit recording test PASSED");
+						} else {
+							console.log("❌ Recording file does not exist");
+							console.log(
+								"🔍 This might be due to permissions or ScreenCaptureKit configuration"
+							);
+						}
+					} catch (error) {
+						console.error("❌ Final check error:", error.message);
+					}
+
+					console.log("\n✅ Recording test completed");
+				}, 4000);
+			}, 6000);
+		} else {
+			console.log("❌ Failed to start recording");
+			console.log("🔍 Possible causes:");
+			console.log("   • Screen recording permissions not granted");
+			console.log("   • ScreenCaptureKit not available (requires macOS 12.3+)");
+			console.log("   • Display/window selection issues");
+		}
+	} catch (error) {
+		console.error("❌ Recording test failed with exception:", error);
+	}
+}
+
+// Handle process exit
+process.on("SIGINT", () => {
+	console.log("\n⚠️  Recording test interrupted");
+	process.exit(0);
+});
+
+testRecording();

package/test-sck-simple.js

@@ -0,0 +1,37 @@
+const MacRecorder = require('./index');
+
+async function testScreenCaptureKit() {
+    console.log('Testing ScreenCaptureKit migration...');
+    
+    const recorder = new MacRecorder();
+    
+    try {
+        // Test 1: Check permissions
+        console.log('\n1. Testing checkPermissions()');
+        const permissions = await recorder.checkPermissions();
+        console.log('✅ Permissions:', permissions);
+        
+        // Test 2: Get displays
+        console.log('\n2. Testing getDisplays()');
+        const displays = await recorder.getDisplays();
+        console.log(`✅ Found ${displays.length} displays:`, displays.map(d => `${d.id}:${d.width}x${d.height}`));
+        
+        // Test 3: Get windows
+        console.log('\n3. Testing getWindows()');
+        const windows = await recorder.getWindows();
+        console.log(`✅ Found ${windows.length} windows:`, windows.slice(0, 3).map(w => `${w.id}:"${w.title}"`));
+        
+        // Test 4: Get audio devices
+        console.log('\n4. Testing getAudioDevices()');
+        const audioDevices = await recorder.getAudioDevices();
+        console.log(`✅ Found ${audioDevices.length} audio devices:`, audioDevices.slice(0, 3).map(d => `${d.id}:"${d.name}"`));
+        
+        console.log('\n🎉 All ScreenCaptureKit tests passed!');
+        console.log('\n✅ ScreenCaptureKit migration successful!');
+        
+    } catch (error) {
+        console.error('❌ Test failed:', error);
+    }
+}
+
+testScreenCaptureKit();

package/test-sck.js

@@ -0,0 +1,109 @@
+<<<<<<< HEAD
+const nativeBinding = require('./build/Release/mac_recorder.node');
+
+console.log('=== ScreenCaptureKit Migration Test ===');
+console.log('ScreenCaptureKit available:', nativeBinding.isScreenCaptureKitAvailable());
+console.log('Displays:', nativeBinding.getDisplays().length);
+console.log('Audio devices:', nativeBinding.getAudioDevices().length);
+console.log('Permissions OK:', nativeBinding.checkPermissions());
+
+const displays = nativeBinding.getDisplays();
+console.log('\nDisplay info:', displays[0]);
+
+const audioDevices = nativeBinding.getAudioDevices();
+console.log('\nFirst audio device:', audioDevices[0]);
+
+// Test starting and stopping recording
+console.log('\n=== Recording Test ===');
+const outputPath = '/tmp/test-recording-sck.mov';
+
+try {
+    console.log('Starting recording...');
+    const success = nativeBinding.startRecording(outputPath, {
+        displayId: displays[0].id,
+        captureCursor: true,
+        includeMicrophone: false,
+        includeSystemAudio: false
+    });
+    
+    console.log('Recording started:', success);
+    
+    if (success) {
+        setTimeout(() => {
+            console.log('Stopping recording...');
+            const stopped = nativeBinding.stopRecording();
+            console.log('Recording stopped:', stopped);
+            
+            // Check if file was created
+            const fs = require('fs');
+            setTimeout(() => {
+                if (fs.existsSync(outputPath)) {
+                    const stats = fs.statSync(outputPath);
+                    console.log(`Recording file created: ${outputPath} (${stats.size} bytes)`);
+                } else {
+                    console.log('Recording file not found');
+                }
+            }, 1000);
+        }, 3000); // Record for 3 seconds
+    }
+} catch (error) {
+    console.error('Recording test failed:', error.message);
+}
+=======
+const MacRecorder = require('./index');
+
+function testScreenCaptureKit() {
+    console.log('Testing ScreenCaptureKit migration...');
+    
+    const recorder = new MacRecorder();
+    
+    try {
+        // Test getting displays
+        console.log('\n1. Testing getDisplays()');
+        recorder.getDisplays((err, displays) => {
+            if (err) {
+                console.error('getDisplays failed:', err);
+                return;
+            }
+            console.log(`Found ${displays.length} displays:`, displays);
+            
+            // Test getting windows
+            console.log('\n2. Testing getWindows()');
+            recorder.getWindows((err, windows) => {
+                if (err) {
+                    console.error('getWindows failed:', err);
+                    return;
+                }
+                console.log(`Found ${windows.length} windows:`, windows.slice(0, 3));
+                
+                // Test getting audio devices
+                console.log('\n3. Testing getAudioDevices()');
+                recorder.getAudioDevices((err, audioDevices) => {
+                    if (err) {
+                        console.error('getAudioDevices failed:', err);
+                        return;
+                    }
+                    console.log(`Found ${audioDevices.length} audio devices:`, audioDevices.slice(0, 3));
+                    
+                    // Test permissions
+                    console.log('\n4. Testing checkPermissions()');
+                    recorder.checkPermissions((err, hasPermissions) => {
+                        if (err) {
+                            console.error('checkPermissions failed:', err);
+                            return;
+                        }
+                        console.log(`Has permissions: ${hasPermissions}`);
+                        
+                        console.log('\n✅ All basic tests passed! ScreenCaptureKit migration successful.');
+                    });
+                });
+            });
+        });
+        
+    } catch (error) {
+        console.error('❌ Test failed:', error);
+    }
+}
+
+testScreenCaptureKit();
+>>>>>>> screencapture

package/test-sync.js

@@ -0,0 +1,52 @@
+const MacRecorder = require('./index');
+
+console.log('🔄 Testing ScreenCaptureKit Synchronous Operations...\n');
+
+try {
+    const recorder = new MacRecorder();
+    console.log('✅ Recorder created successfully');
+    
+    // Test if we can access the native module methods directly
+    console.log('📋 Available methods:');
+    const methods = Object.getOwnPropertyNames(recorder.__proto__);
+    methods.forEach(method => {
+        if (typeof recorder[method] === 'function') {
+            console.log(`   • ${method}()`);
+        }
+    });
+    
+    console.log('\n🎯 Testing basic functionality:');
+    
+    // Test recording status (should be sync and work)
+    try {
+        const status = recorder.getStatus();
+        console.log(`✅ getStatus(): ${JSON.stringify(status)}`);
+    } catch (err) {
+        console.log(`❌ getStatus() failed: ${err.message}`);
+    }
+    
+    // Test cursor position (should be sync and work)
+    try {
+        const cursor = recorder.getCurrentCursorPosition();
+        console.log(`✅ getCurrentCursorPosition(): x=${cursor.x}, y=${cursor.y}, type=${cursor.cursorType}`);
+    } catch (err) {
+        console.log(`❌ getCurrentCursorPosition() failed: ${err.message}`);
+    }
+    
+    // Test cursor capture status (should be sync)
+    try {
+        const cursorStatus = recorder.getCursorCaptureStatus();
+        console.log(`✅ getCursorCaptureStatus(): tracking=${cursorStatus.isTracking}`);
+    } catch (err) {
+        console.log(`❌ getCursorCaptureStatus() failed: ${err.message}`);
+    }
+    
+    console.log('\n📊 ScreenCaptureKit sync tests completed');
+    console.log('⚠️  Async functions (getDisplays, getWindows, getAudioDevices) may hang due to permission dialogs');
+    console.log('💡 To fix: Grant screen recording permissions in System Preferences > Privacy & Security');
+    
+} catch (error) {
+    console.error('❌ Critical error:', error);
+}
+
+process.exit(0);

package/test-windows.js

@@ -0,0 +1,57 @@
+const MacRecorder = require('./index');
+
+function testWindowSelection() {
+    console.log('🔍 Testing ScreenCaptureKit Window Selection...\n');
+    
+    const recorder = new MacRecorder();
+    
+    try {
+        // Test window enumeration
+        recorder.getWindows((err, windows) => {
+            if (err) {
+                console.error('❌ getWindows failed:', err);
+                return;
+            }
+            
+            console.log(`✅ Found ${windows.length} windows`);
+            
+            // Show first few windows with details
+            windows.slice(0, 5).forEach((window, index) => {
+                console.log(`${index + 1}. "${window.name}" - ${window.appName}`);
+                console.log(`   ID: ${window.id}, Size: ${window.width}x${window.height}, Position: (${window.x}, ${window.y})`);
+                console.log(`   On Screen: ${window.isOnScreen !== false ? 'Yes' : 'No'}\n`);
+            });
+            
+            // Test window thumbnails if we have windows
+            if (windows.length > 0) {
+                const firstWindow = windows[0];
+                console.log(`📸 Testing window thumbnail for: "${firstWindow.name}"`);
+                
+                recorder.getWindowThumbnail(firstWindow.id, 300, 200, (err, thumbnail) => {
+                    if (err) {
+                        console.error('❌ getWindowThumbnail failed:', err);
+                    } else {
+                        console.log(`✅ Window thumbnail generated: ${thumbnail.length} characters (base64)`);
+                        
+                        // Test window recording info
+                        console.log(`\n🎬 Window recording info:`);
+                        console.log(`   Target Window: "${firstWindow.name}" (ID: ${firstWindow.id})`);
+                        console.log(`   App: ${firstWindow.appName}`);
+                        console.log(`   Capture Area: ${firstWindow.width}x${firstWindow.height}`);
+                        console.log(`   Would use windowId option for recording`);
+                        
+                        console.log('\n✅ Window selection tests completed successfully!');
+                    }
+                });
+            } else {
+                console.log('⚠️ No windows found for thumbnail testing');
+                console.log('\n✅ Window enumeration test completed successfully!');
+            }
+        });
+        
+    } catch (error) {
+        console.error('❌ Window selection test failed:', error);
+    }
+}
+
+testWindowSelection();