node-mac-recorder 2.17.20 → 2.17.21

package/test-primary-cursor.js

@@ -1,154 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function testPrimaryCursor() {
-    console.log('🧪 Testing cursor coordinates on primary vs secondary displays...');
-
-    const recorder = new MacRecorder();
-
-    try {
-        // Get available displays and windows
-        const displays = await recorder.getDisplays();
-        const windows = await recorder.getWindows();
-
-        console.log('\n📱 Available displays:');
-        displays.forEach((display, i) => {
-            const type = display.isPrimary ? 'PRIMARY' : 'SECONDARY';
-            console.log(`  ${i + 1}. ${type} Display ${display.id}: ${display.resolution} at (${display.x}, ${display.y})`);
-        });
-
-        // Find windows on each display
-        const primaryDisplay = displays.find(d => d.isPrimary);
-        const secondaryDisplay = displays.find(d => !d.isPrimary);
-
-        console.log('\n🪟 Finding windows on each display:');
-
-        const primaryWindows = windows.filter(window => {
-            const windowCenterX = window.x + window.width / 2;
-            const windowCenterY = window.y + window.height / 2;
-            return (windowCenterX >= primaryDisplay.x &&
-                    windowCenterX < primaryDisplay.x + primaryDisplay.width &&
-                    windowCenterY >= primaryDisplay.y &&
-                    windowCenterY < primaryDisplay.y + primaryDisplay.height);
-        });
-
-        const secondaryWindows = secondaryDisplay ? windows.filter(window => {
-            const windowCenterX = window.x + window.width / 2;
-            const windowCenterY = window.y + window.height / 2;
-            return (windowCenterX >= secondaryDisplay.x &&
-                    windowCenterX < secondaryDisplay.x + secondaryDisplay.width &&
-                    windowCenterY >= secondaryDisplay.y &&
-                    windowCenterY < secondaryDisplay.y + secondaryDisplay.height);
-        }) : [];
-
-        console.log(`\n📊 Window distribution:`);
-        console.log(`   Primary display: ${primaryWindows.length} windows`);
-        console.log(`   Secondary display: ${secondaryWindows.length} windows`);
-
-        // Test each display type
-        for (const displayType of ['primary', 'secondary']) {
-            const display = displayType === 'primary' ? primaryDisplay : secondaryDisplay;
-            const windowList = displayType === 'primary' ? primaryWindows : secondaryWindows;
-
-            if (!display) {
-                console.log(`\n⚠️ No ${displayType} display found, skipping...`);
-                continue;
-            }
-
-            if (windowList.length === 0) {
-                console.log(`\n⚠️ No windows found on ${displayType} display, skipping...`);
-                continue;
-            }
-
-            const testWindow = windowList[0];
-            console.log(`\n🎯 Testing ${displayType.toUpperCase()} display (${display.id}):`);
-            console.log(`   Display bounds: (${display.x}, ${display.y}) ${display.width}x${display.height}`);
-            console.log(`   Test window: "${testWindow.title}" at (${testWindow.x}, ${testWindow.y}) ${testWindow.width}x${testWindow.height}`);
-
-            // Calculate window position relative to display
-            const windowRelativeX = testWindow.x - display.x;
-            const windowRelativeY = testWindow.y - display.y;
-            console.log(`   Window relative to display: (${windowRelativeX}, ${windowRelativeY})`);
-
-            // Test cursor capture
-            const outputFile = `./test-output/cursor-${displayType}-${Date.now()}.json`;
-
-            console.log(`\n🖱️ Starting cursor test for ${displayType} display...`);
-            console.log('   Move mouse over the test window for 3 seconds');
-
-            await recorder.startCursorCapture(outputFile, {
-                windowRelative: true,
-                windowInfo: {
-                    x: testWindow.x,
-                    y: testWindow.y,
-                    width: testWindow.width,
-                    height: testWindow.height,
-                    displayId: display.id,
-                    targetDisplay: display
-                }
-            });
-
-            // Capture for 3 seconds
-            await new Promise(resolve => setTimeout(resolve, 3000));
-
-            await recorder.stopCursorCapture();
-
-            // Analyze results
-            const fs = require('fs');
-            if (fs.existsSync(outputFile)) {
-                const cursorData = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
-
-                console.log(`\n📊 ${displayType.toUpperCase()} Display Results:`);
-                console.log(`   Captured events: ${cursorData.length}`);
-
-                if (cursorData.length > 0) {
-                    const inBounds = cursorData.filter(event =>
-                        event.x >= 0 && event.x < testWindow.width &&
-                        event.y >= 0 && event.y < testWindow.height
-                    );
-
-                    const outOfBounds = cursorData.filter(event =>
-                        event.x < 0 || event.x >= testWindow.width ||
-                        event.y < 0 || event.y >= testWindow.height
-                    );
-
-                    console.log(`   Events in bounds: ${inBounds.length}/${cursorData.length} (${Math.round(inBounds.length/cursorData.length*100)}%)`);
-                    console.log(`   Events out of bounds: ${outOfBounds.length}`);
-
-                    if (outOfBounds.length > 0) {
-                        console.log(`   ❌ ISSUE DETECTED on ${displayType} display!`);
-                        console.log(`   Sample out-of-bounds coordinates:`);
-                        outOfBounds.slice(0, 5).forEach(event => {
-                            console.log(`      (${event.x}, ${event.y}) - should be 0-${testWindow.width}, 0-${testWindow.height}`);
-                        });
-
-                        // Analyze the offset pattern
-                        const xOffsets = outOfBounds.map(e => e.x);
-                        const yOffsets = outOfBounds.map(e => e.y);
-                        const avgXOffset = xOffsets.reduce((a, b) => a + b, 0) / xOffsets.length;
-                        const avgYOffset = yOffsets.reduce((a, b) => a + b, 0) / yOffsets.length;
-
-                        console.log(`   📊 Average coordinate offsets: X=${avgXOffset.toFixed(1)}, Y=${avgYOffset.toFixed(1)}`);
-                    } else {
-                        console.log(`   ✅ All coordinates within bounds on ${displayType} display`);
-                    }
-
-                    // Show coordinate samples
-                    console.log(`   Sample coordinates (first 3):`);
-                    cursorData.slice(0, 3).forEach((event, i) => {
-                        console.log(`      ${i+1}. (${event.x}, ${event.y}) - ${event.coordinateSystem}`);
-                    });
-                }
-            }
-        }
-
-        console.log('\n🔍 Analysis Summary:');
-        console.log('   If primary display shows out-of-bounds coordinates,');
-        console.log('   but secondary display works correctly, this indicates');
-        console.log('   a coordinate transformation issue specific to primary displays.');
-
-    } catch (error) {
-        console.error('❌ Test failed:', error.message);
-    }
-}
-
-testPrimaryCursor().catch(console.error);

package/test-primary-fix.js

@@ -1,120 +0,0 @@
-const MacRecorder = require('./index.js');
-
-async function testPrimaryFix() {
-    console.log('🧪 Testing fixed cursor coordinates on primary display...');
-
-    const recorder = new MacRecorder();
-
-    try {
-        const displays = await recorder.getDisplays();
-        const windows = await recorder.getWindows();
-
-        const primaryDisplay = displays.find(d => d.isPrimary);
-        const primaryWindows = windows.filter(window => {
-            const windowCenterX = window.x + window.width / 2;
-            const windowCenterY = window.y + window.height / 2;
-            return (windowCenterX >= primaryDisplay.x &&
-                    windowCenterX < primaryDisplay.x + primaryDisplay.width &&
-                    windowCenterY >= primaryDisplay.y &&
-                    windowCenterY < primaryDisplay.y + primaryDisplay.height);
-        });
-
-        if (primaryWindows.length === 0) {
-            console.log('❌ No windows found on primary display');
-            return;
-        }
-
-        const testWindow = primaryWindows[0];
-
-        console.log('\n🎯 Testing PRIMARY display window recording:');
-        console.log(`   Display: ${primaryDisplay.width}x${primaryDisplay.height} at (${primaryDisplay.x}, ${primaryDisplay.y})`);
-        console.log(`   Window: "${testWindow.title}" ${testWindow.width}x${testWindow.height} at (${testWindow.x}, ${testWindow.y})`);
-
-        // Calculate expected coordinates
-        console.log('\n📊 Expected transformation:');
-        console.log(`   Window top-left (${testWindow.x}, ${testWindow.y}) should become (0, 0)`);
-        console.log(`   Window bottom-right (${testWindow.x + testWindow.width}, ${testWindow.y + testWindow.height}) should become (${testWindow.width}, ${testWindow.height})`);
-
-        // Start cursor capture
-        const outputFile = `./test-output/primary-fix-test-${Date.now()}.json`;
-
-        await recorder.startCursorCapture(outputFile, {
-            windowRelative: true,
-            windowInfo: {
-                x: testWindow.x,
-                y: testWindow.y,
-                width: testWindow.width,
-                height: testWindow.height,
-                displayId: primaryDisplay.id
-            }
-        });
-
-        console.log('\n🖱️ Move mouse over the test window for 5 seconds...');
-        console.log(`   Try to move cursor to different corners of the window`);
-        console.log(`   Window boundaries: (0,0) to (${testWindow.width}, ${testWindow.height})`);
-
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
-        await recorder.stopCursorCapture();
-
-        // Analyze results
-        const fs = require('fs');
-        if (fs.existsSync(outputFile)) {
-            const cursorData = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
-
-            console.log('\n📊 PRIMARY Display Test Results:');
-            console.log(`   Captured events: ${cursorData.length}`);
-
-            if (cursorData.length > 0) {
-                const inBounds = cursorData.filter(event =>
-                    event.x >= 0 && event.x < testWindow.width &&
-                    event.y >= 0 && event.y < testWindow.height
-                );
-
-                const outOfBounds = cursorData.filter(event =>
-                    event.x < 0 || event.x >= testWindow.width ||
-                    event.y < 0 || event.y >= testWindow.height
-                );
-
-                console.log(`   Events in bounds: ${inBounds.length}/${cursorData.length} (${Math.round(inBounds.length/cursorData.length*100)}%)`);
-
-                if (outOfBounds.length > 0) {
-                    console.log(`   ❌ STILL HAVE ISSUES: ${outOfBounds.length} events out of bounds`);
-                    console.log(`   Sample problematic coordinates:`);
-                    outOfBounds.slice(0, 3).forEach(event => {
-                        console.log(`      (${event.x}, ${event.y}) - should be within 0-${testWindow.width}, 0-${testWindow.height}`);
-                    });
-                } else {
-                    console.log(`   ✅ ALL COORDINATES WITHIN BOUNDS - Primary display fix successful!`);
-                }
-
-                // Show coordinate range
-                const xCoords = cursorData.map(e => e.x);
-                const yCoords = cursorData.map(e => e.y);
-                const minX = Math.min(...xCoords);
-                const maxX = Math.max(...xCoords);
-                const minY = Math.min(...yCoords);
-                const maxY = Math.max(...yCoords);
-
-                console.log(`   Coordinate ranges: X=${minX} to ${maxX}, Y=${minY} to ${maxY}`);
-
-                // Check coordinate system
-                const firstEvent = cursorData[0];
-                console.log(`   Coordinate system: ${firstEvent.coordinateSystem}`);
-
-                if (firstEvent.coordinateSystem === "window-relative") {
-                    console.log(`   ✅ Coordinate system correctly set`);
-                } else {
-                    console.log(`   ❌ Coordinate system incorrect: ${firstEvent.coordinateSystem}`);
-                }
-            }
-        } else {
-            console.log('❌ No output file created');
-        }
-
-    } catch (error) {
-        console.error('❌ Test failed:', error.message);
-    }
-}
-
-testPrimaryFix().catch(console.error);

package/test-recording-with-cursor.js

@@ -1,83 +0,0 @@
-#!/usr/bin/env node
-
-const MacRecorder = require('./index.js');
-const fs = require('fs');
-const path = require('path');
-
-async function testRecordingWithCursor() {
-    const recorder = new MacRecorder();
-
-    console.log('🎯 Testing recording with cursor tracking...');
-
-    // Create test output directory
-    const outputDir = './test-output';
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir);
-    }
-
-    const videoPath = path.join(outputDir, `test-recording-${Date.now()}.mov`);
-
-    try {
-        console.log('Starting recording with auto cursor tracking...');
-
-        // Start recording (should auto-start cursor tracking)
-        await recorder.startRecording(videoPath, {
-            captureCursor: true, // This should trigger auto cursor tracking
-            quality: 'low',
-            frameRate: 10
-        });
-
-        console.log('✅ Recording started successfully');
-        console.log('🔥 Recording for 3 seconds...');
-
-        // Wait 3 seconds
-        await new Promise(resolve => setTimeout(resolve, 3000));
-
-        console.log('Stopping recording...');
-        const stopResult = await recorder.stopRecording();
-        console.log('✅ Recording stopped:', stopResult);
-
-        // Wait a bit for file to be written
-        await new Promise(resolve => setTimeout(resolve, 1000));
-
-        // Check if files exist
-        if (fs.existsSync(videoPath)) {
-            const videoStats = fs.statSync(videoPath);
-            console.log('📹 Video file size:', videoStats.size, 'bytes');
-        } else {
-            console.log('❌ Video file not found:', videoPath);
-        }
-
-        // Check for cursor files
-        const cursorFiles = fs.readdirSync(outputDir).filter(f => f.includes('cursor') && f.endsWith('.json'));
-        console.log('📊 Cursor files found:', cursorFiles.length);
-
-        if (cursorFiles.length > 0) {
-            const cursorFile = path.join(outputDir, cursorFiles[0]);
-            const cursorContent = fs.readFileSync(cursorFile, 'utf8');
-            console.log('📁 Cursor file size:', cursorContent.length, 'bytes');
-
-            if (cursorContent.trim()) {
-                try {
-                    const cursorData = JSON.parse(cursorContent);
-                    console.log('📍 Cursor data points:', cursorData.length);
-                } catch (parseError) {
-                    console.log('⚠️ Cursor file content preview:', cursorContent.substring(0, 200));
-                }
-            }
-        }
-
-    } catch (error) {
-        console.error('❌ Test failed:', error.message);
-        console.error('Stack:', error.stack);
-    }
-}
-
-// Run test
-testRecordingWithCursor().then(() => {
-    console.log('\n✨ Test completed');
-    process.exit(0);
-}).catch(error => {
-    console.error('💥 Test error:', error);
-    process.exit(1);
-});

package/test-unified-cursor.js

@@ -1,75 +0,0 @@
-#!/usr/bin/env node
-
-const MacRecorder = require('./index.js');
-const fs = require('fs');
-const path = require('path');
-
-async function testUnifiedCursorTracking() {
-    const recorder = new MacRecorder();
-
-    console.log('🎯 Testing unified cursor tracking...');
-
-    // Create test output directory
-    const outputDir = './test-output';
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir);
-    }
-
-    const cursorFilePath = path.join(outputDir, `unified-cursor-${Date.now()}.json`);
-
-    try {
-        console.log('Starting native cursor tracking...');
-
-        // Test native cursor tracking
-        const result = await recorder.startCursorCapture(cursorFilePath);
-        console.log('✅ Cursor tracking started:', result);
-
-        console.log('\n🔥 Move your mouse around for 5 seconds...');
-
-        // Wait 5 seconds
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
-        console.log('\nStopping cursor tracking...');
-        const stopped = recorder.stopCursorCapture();
-        console.log('✅ Cursor tracking stopped:', stopped);
-
-        // Wait a bit for file to be written
-        await new Promise(resolve => setTimeout(resolve, 1000));
-
-        // Check if file exists and has content
-        if (fs.existsSync(cursorFilePath)) {
-            const fileContent = fs.readFileSync(cursorFilePath, 'utf8');
-            console.log('📁 File size:', fileContent.length, 'bytes');
-
-            try {
-                const cursorData = JSON.parse(fileContent);
-                console.log('📊 Cursor data points:', cursorData.length);
-
-                if (cursorData.length > 0) {
-                    console.log('📍 First point:', cursorData[0]);
-                    console.log('📍 Last point:', cursorData[cursorData.length - 1]);
-
-                    // Check coordinate system
-                    const coordinateSystems = [...new Set(cursorData.map(p => p.coordinateSystem))];
-                    console.log('🔧 Coordinate systems used:', coordinateSystems);
-                }
-            } catch (parseError) {
-                console.log('⚠️ File content (first 500 chars):', fileContent.substring(0, 500));
-            }
-        } else {
-            console.log('❌ Output file not found:', cursorFilePath);
-        }
-
-    } catch (error) {
-        console.error('❌ Test failed:', error.message);
-    }
-}
-
-// Run test
-testUnifiedCursorTracking().then(() => {
-    console.log('\n✨ Test completed');
-    process.exit(0);
-}).catch(error => {
-    console.error('💥 Test error:', error);
-    process.exit(1);
-});

package/test-window-recording.js

@@ -1,149 +0,0 @@
-#!/usr/bin/env node
-
-const MacRecorder = require('./index.js');
-const path = require('path');
-const fs = require('fs');
-
-// Test output directory
-const outputDir = './test-output';
-if (!fs.existsSync(outputDir)) {
-	fs.mkdirSync(outputDir, { recursive: true });
-}
-
-const recorder = new MacRecorder();
-
-async function testWindowRecording() {
-	console.log('🎬 Testing window recording with automatic cursor tracking...');
-
-	try {
-		// Test permissions first
-		const permissions = await recorder.checkPermissions();
-		console.log('📋 Permissions:', permissions);
-
-		if (!permissions.screenRecording) {
-			console.log('❌ Screen recording permission required');
-			return;
-		}
-
-		// Get windows
-		const windows = await recorder.getWindows();
-		console.log(`🪟 Found ${windows.length} windows`);
-
-		// Find a suitable window to record (preferably a visible one)
-		const visibleWindows = windows.filter(w => w.width > 200 && w.height > 100);
-		if (visibleWindows.length === 0) {
-			console.log('❌ No suitable windows found for recording');
-			return;
-		}
-
-		const targetWindow = visibleWindows[0];
-		console.log(`🎯 Target window: ${targetWindow.appName} (${targetWindow.width}x${targetWindow.height})`);
-		console.log(`📍 Window position: (${targetWindow.x}, ${targetWindow.y})`);
-
-		// Setup recording options
-		const timestamp = Date.now();
-		const videoPath = path.join(outputDir, `window-test-${timestamp}.mov`);
-
-		console.log(`🎥 Starting window recording to: ${videoPath}`);
-		console.log('🖱️  Cursor tracking will use window-relative coordinates');
-		console.log('💡 Move your mouse over the target window to generate cursor data');
-
-		// Start recording the specific window (cursor tracking will start automatically)
-		await recorder.startRecording(videoPath, {
-			includeMicrophone: false,
-			includeSystemAudio: false,
-			captureCursor: true,
-			windowId: targetWindow.id
-		});
-
-		console.log('✅ Window recording started successfully!');
-		console.log('🖱️  Cursor tracking started automatically with window-relative coordinates');
-		console.log('⏰ Recording for 8 seconds...');
-		console.log(`🔍 Please move your mouse over the "${targetWindow.appName}" window`);
-
-		// Wait for 8 seconds
-		await new Promise(resolve => setTimeout(resolve, 8000));
-
-		console.log('🛑 Stopping recording...');
-
-		// Stop recording (cursor tracking will stop automatically)
-		const result = await recorder.stopRecording();
-
-		console.log('✅ Recording stopped:', result);
-		console.log('📁 Checking output files...');
-
-		// Wait a moment for files to be written
-		await new Promise(resolve => setTimeout(resolve, 1000));
-
-		// Check for video file
-		if (fs.existsSync(videoPath)) {
-			const videoStats = fs.statSync(videoPath);
-			console.log(`📹 Video file created: ${path.basename(videoPath)} (${videoStats.size} bytes)`);
-		} else {
-			console.log('❌ Video file not found');
-		}
-
-		// Check for cursor file
-		const files = fs.readdirSync(outputDir);
-		const cursorFile = files.find(f => f.startsWith('temp_cursor_') && f.endsWith('.json'));
-
-		if (cursorFile) {
-			const cursorPath = path.join(outputDir, cursorFile);
-			const cursorStats = fs.statSync(cursorPath);
-			console.log(`🖱️  Cursor file created: ${cursorFile} (${cursorStats.size} bytes)`);
-
-			// Read and validate cursor data
-			try {
-				const cursorData = JSON.parse(fs.readFileSync(cursorPath, 'utf8'));
-				console.log(`📊 Cursor data points: ${cursorData.length}`);
-
-				if (cursorData.length > 0) {
-					const first = cursorData[0];
-					const last = cursorData[cursorData.length - 1];
-
-					console.log(`📍 First cursor position: (${first.x}, ${first.y}) at ${first.timestamp}ms`);
-					console.log(`📍 Last cursor position: (${last.x}, ${last.y}) at ${last.timestamp}ms`);
-					console.log(`📐 Coordinate system: ${first.coordinateSystem}`);
-
-					if (first.windowInfo) {
-						console.log(`🪟 Window info: ${first.windowInfo.width}x${first.windowInfo.height}`);
-						console.log(`🌐 Original window position: (${first.windowInfo.originalWindow?.x}, ${first.windowInfo.originalWindow?.y})`);
-					}
-
-					// Analyze cursor positions
-					const windowRelativePositions = cursorData.filter(d => d.coordinateSystem === 'window-relative');
-					if (windowRelativePositions.length > 0) {
-						console.log(`✅ ${windowRelativePositions.length} window-relative cursor positions recorded`);
-
-						// Check if coordinates are within window bounds
-						const validPositions = windowRelativePositions.filter(d =>
-							d.x >= 0 && d.y >= 0 &&
-							d.x <= targetWindow.width && d.y <= targetWindow.height
-						);
-
-						console.log(`✅ ${validPositions.length}/${windowRelativePositions.length} positions within window bounds`);
-					}
-				}
-			} catch (parseError) {
-				console.log('⚠️  Could not parse cursor data:', parseError.message);
-			}
-		} else {
-			console.log('❌ Cursor file not found');
-		}
-
-		console.log('✅ Window recording test completed!');
-
-	} catch (error) {
-		console.error('❌ Test failed:', error.message);
-		console.error(error.stack);
-	}
-}
-
-// Run the test
-testWindowRecording().then(() => {
-	console.log('🏁 Window recording test finished');
-	process.exit(0);
-}).catch(error => {
-	console.error('💥 Fatal error:', error);
-	process.exit(1);
-});