node-mac-recorder 2.16.32 → 2.17.0

package/.claude/settings.local.json

@@ -1,7 +1,9 @@
 {
   "permissions": {
     "allow": [
-      "Bash(node:*)"
+      "Bash(node:*)",
+      "Bash(chmod:*)",
+      "Bash(cat:*)"
     ],
     "deny": [],
     "ask": []

package/cursor-macbook-test.js

@@ -0,0 +1,63 @@
+const MacRecorder = require('./index.js');
+
+async function testMacBookCursor() {
+    console.log('🖥️  Testing cursor on MacBook internal display...\n');
+    
+    const recorder = new MacRecorder();
+    
+    // Get displays
+    const displays = await recorder.getDisplays();
+    console.log('📺 Available displays:');
+    displays.forEach((display, index) => {
+        console.log(`   Display ${index}: ${display.resolution} at (${display.x}, ${display.y}) - Primary: ${display.isPrimary}`);
+    });
+    
+    console.log('\n🎯 Move your mouse to the PRIMARY MacBook display and press any key...');
+    console.log('(Make sure cursor is on the built-in MacBook screen, not external monitor)\n');
+    
+    // Wait for keypress
+    await new Promise((resolve) => {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.once('data', () => {
+            process.stdin.setRawMode(false);
+            resolve();
+        });
+    });
+    
+    console.log('🔍 Testing cursor position on MacBook display:');
+    for (let i = 0; i < 3; i++) {
+        const position = recorder.getCursorPosition();
+        console.log(`\n   Test ${i+1}:`);
+        console.log(`     Cursor: (${position.x}, ${position.y})`);
+        console.log(`     Cursor type: ${position.cursorType}`);
+        
+        // Check which display cursor is on
+        const primaryDisplay = displays.find(d => d.isPrimary);
+        if (primaryDisplay) {
+            const isOnPrimary = position.x >= primaryDisplay.x && 
+                               position.x < primaryDisplay.x + parseInt(primaryDisplay.resolution.split('x')[0]) &&
+                               position.y >= primaryDisplay.y && 
+                               position.y < primaryDisplay.y + parseInt(primaryDisplay.resolution.split('x')[1]);
+            
+            console.log(`     On primary display: ${isOnPrimary ? '✅ YES' : '❌ NO'}`);
+        }
+        
+        if (position.scaleFactor) {
+            console.log(`     Scale factor: ${position.scaleFactor}x`);
+            if (position.displayInfo) {
+                console.log(`     Display logical: ${position.displayInfo.logicalWidth}x${position.displayInfo.logicalHeight}`);
+                console.log(`     Display physical: ${position.displayInfo.physicalWidth}x${position.displayInfo.physicalHeight}`);
+                console.log(`     Raw cursor: (${position.rawX}, ${position.rawY})`);
+            }
+        } else {
+            console.log(`     ⚠️ No scaling info detected`);
+        }
+        
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    
+    process.exit(0);
+}
+
+testMacBookCursor().catch(console.error);

package/cursor-simple-test.js

@@ -0,0 +1,26 @@
+const MacRecorder = require('./index.js');
+
+console.log('🎯 Simple cursor test - Move your mouse to MacBook screen...\n');
+
+const recorder = new MacRecorder();
+
+// Test 10 cursor positions
+for (let i = 0; i < 10; i++) {
+    setTimeout(() => {
+        const position = recorder.getCursorPosition();
+        console.log(`${i+1}. Cursor: (${position.x}, ${position.y}), Scale: ${position.scaleFactor || 'none'}`);
+        
+        if (position.displayInfo && position.scaleFactor > 1.1) {
+            console.log(`   🎉 SCALING DETECTED! ${position.scaleFactor}x`);
+            console.log(`   Logical: ${position.displayInfo.logicalWidth}x${position.displayInfo.logicalHeight}`);
+            console.log(`   Physical: ${position.displayInfo.physicalWidth}x${position.displayInfo.physicalHeight}`);
+            console.log(`   Raw cursor: (${position.rawX}, ${position.rawY})`);
+            process.exit(0);
+        }
+        
+        if (i === 9) {
+            console.log('\n⚠️ No scaling detected. Try moving mouse to MacBook internal display.');
+            process.exit(0);
+        }
+    }, i * 500);
+}

package/index.js

@@ -315,6 +315,11 @@ class MacRecorder extends EventEmitter {
 
 		return new Promise((resolve, reject) => {
 			try {
+				// Create cursor file path with timestamp in the same directory as video
+				const timestamp = Date.now();
+				const outputDir = path.dirname(outputPath);
+				const cursorFilePath = path.join(outputDir, `temp_cursor_${timestamp}.json`);
+
 				// Native kayıt başlat
 				const recordingOptions = {
 					includeMicrophone: this.options.includeMicrophone === true, // Only if explicitly enabled
@@ -351,6 +356,20 @@ class MacRecorder extends EventEmitter {
 					this.isRecording = true;
 					this.recordingStartTime = Date.now();
 
+					// Start cursor tracking automatically with recording
+					this.startCursorCapture(cursorFilePath, {
+						windowRelative: !!this.options.windowId,
+						windowInfo: this.options.windowId ? {
+							x: this.options.captureArea?.x || 0,
+							y: this.options.captureArea?.y || 0,
+							width: this.options.captureArea?.width || 1920,
+							height: this.options.captureArea?.height || 1080,
+							displayId: this.options.displayId
+						} : null
+					}).catch(cursorError => {
+						console.warn('Cursor tracking failed to start:', cursorError.message);
+					});
+
 					// Timer başlat (progress tracking için)
 					this.recordingTimer = setInterval(() => {
 						const elapsed = Math.floor(
@@ -441,6 +460,13 @@ class MacRecorder extends EventEmitter {
 					success = true; // Assume success to avoid throwing
 				}
 
+				// Stop cursor tracking automatically
+				if (this.cursorCaptureInterval) {
+					this.stopCursorCapture().catch(cursorError => {
+						console.warn('Cursor tracking failed to stop:', cursorError.message);
+					});
+				}
+
 				// Timer durdur
 				if (this.recordingTimer) {
 					clearInterval(this.recordingTimer);

package/package.json

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

package/src/cursor_tracker.mm

@@ -488,40 +488,110 @@ NSDictionary* getDisplayScalingInfo(CGPoint globalPoint) {
             
             // Check if point is within this display
             if (isInBounds) {
-                // Get display scaling info
+                // CRITICAL FIX: Get REAL physical dimensions using multiple detection methods
+                // Method 1: CGDisplayCreateImage (may be scaled on some systems)
+                CGImageRef testImage = CGDisplayCreateImage(displayID);
+                CGSize imageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
+                CGImageRelease(testImage);
+                
+                // Method 2: Native display mode detection for true physical resolution
+                CGSize actualPhysicalSize = imageSize;
+                CFArrayRef displayModes = CGDisplayCopyAllDisplayModes(displayID, NULL);
+                if (displayModes) {
+                    CFIndex modeCount = CFArrayGetCount(displayModes);
+                    CGSize maxResolution = CGSizeMake(0, 0);
+                    
+                    // Find the highest resolution mode (native resolution)
+                    for (CFIndex i = 0; i < modeCount; i++) {
+                        CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(displayModes, i);
+                        CGSize modeSize = CGSizeMake(CGDisplayModeGetWidth(mode), CGDisplayModeGetHeight(mode));
+                        
+                        if (modeSize.width > maxResolution.width || 
+                            (modeSize.width == maxResolution.width && modeSize.height > maxResolution.height)) {
+                            maxResolution = modeSize;
+                        }
+                    }
+                    
+                    // Use the max resolution if it's significantly higher than image size
+                    if (maxResolution.width > imageSize.width * 1.5 || maxResolution.height > imageSize.height * 1.5) {
+                        actualPhysicalSize = maxResolution;
+                        NSLog(@"🔍 Using display mode detection: %.0fx%.0f (was %.0fx%.0f)", 
+                              maxResolution.width, maxResolution.height, imageSize.width, imageSize.height);
+                    } else {
+                        actualPhysicalSize = imageSize;
+                        NSLog(@"🔍 Using image size detection: %.0fx%.0f", imageSize.width, imageSize.height);
+                    }
+                    
+                    CFRelease(displayModes);
+                } else {
+                    actualPhysicalSize = imageSize;
+                }
+                
                 CGSize logicalSize = displayBounds.size;
-                CGSize physicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
+                CGSize reportedPhysicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
                 
-                NSLog(@"🔍 Scaling info: logical(%.0fx%.0f) physical(%.0fx%.0f)", 
-                      logicalSize.width, logicalSize.height, physicalSize.width, physicalSize.height);
+                NSLog(@"🔍 REAL scaling info:");
+                NSLog(@"   Logical: %.0fx%.0f", logicalSize.width, logicalSize.height);
+                NSLog(@"   Reported physical: %.0fx%.0f", reportedPhysicalSize.width, reportedPhysicalSize.height);
+                NSLog(@"   ACTUAL physical: %.0fx%.0f", actualPhysicalSize.width, actualPhysicalSize.height);
                 
-                CGFloat scaleX = physicalSize.width / logicalSize.width;
-                CGFloat scaleY = physicalSize.height / logicalSize.height;
+                CGFloat scaleX = actualPhysicalSize.width / logicalSize.width;
+                CGFloat scaleY = actualPhysicalSize.height / logicalSize.height;
                 CGFloat scaleFactor = MAX(scaleX, scaleY);
                 
-                NSLog(@"🔍 Scale factors: X=%.2f, Y=%.2f, Final=%.2f", scaleX, scaleY, scaleFactor);
+                NSLog(@"🔍 REAL scale factors: X=%.2f, Y=%.2f, Final=%.2f", scaleX, scaleY, scaleFactor);
                 
                 return @{
                     @"displayID": @(displayID),
                     @"logicalSize": [NSValue valueWithSize:NSMakeSize(logicalSize.width, logicalSize.height)],
-                    @"physicalSize": [NSValue valueWithSize:NSMakeSize(physicalSize.width, physicalSize.height)],
+                    @"physicalSize": [NSValue valueWithSize:NSMakeSize(actualPhysicalSize.width, actualPhysicalSize.height)],
                     @"scaleFactor": @(scaleFactor),
                     @"displayBounds": [NSValue valueWithRect:NSMakeRect(displayBounds.origin.x, displayBounds.origin.y, displayBounds.size.width, displayBounds.size.height)]
                 };
             }
         }
         
-        // Fallback to main display
+        // Fallback to main display with REAL physical dimensions
         CGDirectDisplayID mainDisplay = CGMainDisplayID();
         CGRect displayBounds = CGDisplayBounds(mainDisplay);
+        
+        // Get REAL physical dimensions using multiple detection methods
+        CGImageRef testImage = CGDisplayCreateImage(mainDisplay);
+        CGSize imageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
+        CGImageRelease(testImage);
+        
+        // Try display mode detection for true native resolution
+        CGSize actualPhysicalSize = imageSize;
+        CFArrayRef displayModes = CGDisplayCopyAllDisplayModes(mainDisplay, NULL);
+        if (displayModes) {
+            CFIndex modeCount = CFArrayGetCount(displayModes);
+            CGSize maxResolution = CGSizeMake(0, 0);
+            
+            for (CFIndex i = 0; i < modeCount; i++) {
+                CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(displayModes, i);
+                CGSize modeSize = CGSizeMake(CGDisplayModeGetWidth(mode), CGDisplayModeGetHeight(mode));
+                
+                if (modeSize.width > maxResolution.width || 
+                    (modeSize.width == maxResolution.width && modeSize.height > maxResolution.height)) {
+                    maxResolution = modeSize;
+                }
+            }
+            
+            if (maxResolution.width > imageSize.width * 1.5 || maxResolution.height > imageSize.height * 1.5) {
+                actualPhysicalSize = maxResolution;
+            }
+            
+            CFRelease(displayModes);
+        }
+        
         CGSize logicalSize = displayBounds.size;
-        CGSize physicalSize = CGSizeMake(CGDisplayPixelsWide(mainDisplay), CGDisplayPixelsHigh(mainDisplay));
+        CGFloat scaleFactor = MAX(actualPhysicalSize.width / logicalSize.width, actualPhysicalSize.height / logicalSize.height);
         
         return @{
             @"displayID": @(mainDisplay),
             @"logicalSize": [NSValue valueWithSize:NSMakeSize(logicalSize.width, logicalSize.height)],
-            @"physicalSize": [NSValue valueWithSize:NSMakeSize(physicalSize.width, physicalSize.height)],
-            @"scaleFactor": @(MAX(physicalSize.width / logicalSize.width, physicalSize.height / logicalSize.height)),
+            @"physicalSize": [NSValue valueWithSize:NSMakeSize(actualPhysicalSize.width, actualPhysicalSize.height)],
+            @"scaleFactor": @(scaleFactor),
             @"displayBounds": [NSValue valueWithRect:NSMakeRect(displayBounds.origin.x, displayBounds.origin.y, displayBounds.size.width, displayBounds.size.height)]
         };
     } @catch (NSException *exception) {

package/test-integrated-recording.js

@@ -0,0 +1,120 @@
+#!/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 testIntegratedRecording() {
+	console.log('🎬 Testing integrated screen 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 displays and windows
+		const displays = await recorder.getDisplays();
+		const windows = await recorder.getWindows();
+
+		console.log(`📺 Found ${displays.length} displays and ${windows.length} windows`);
+
+		// Setup recording options
+		const timestamp = Date.now();
+		const videoPath = path.join(outputDir, `integrated-test-${timestamp}.mov`);
+
+		console.log(`🎥 Starting recording to: ${videoPath}`);
+		console.log('📍 Cursor tracking will start automatically and create a JSON file in the same directory');
+
+		// Start recording (cursor tracking will start automatically)
+		// Use the primary display (displayId: 1) where cursor is located
+		await recorder.startRecording(videoPath, {
+			includeMicrophone: false,
+			includeSystemAudio: false,
+			captureCursor: true,
+			displayId: 1  // Use primary display where cursor is located
+		});
+
+		console.log('✅ Recording started successfully!');
+		console.log('🖱️  Cursor tracking started automatically');
+		console.log('⏰ Recording for 5 seconds...');
+		console.log('💡 Move your mouse around to generate cursor data');
+
+		// Wait for 5 seconds
+		await new Promise(resolve => setTimeout(resolve, 5000));
+
+		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: ${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 || 'global'}`);
+				}
+			} catch (parseError) {
+				console.log('⚠️  Could not parse cursor data:', parseError.message);
+			}
+		} else {
+			console.log('❌ Cursor file not found');
+		}
+
+		console.log('✅ Test completed successfully!');
+
+	} catch (error) {
+		console.error('❌ Test failed:', error.message);
+		console.error(error.stack);
+	}
+}
+
+// Run the test
+testIntegratedRecording().then(() => {
+	console.log('🏁 All tests finished');
+	process.exit(0);
+}).catch(error => {
+	console.error('💥 Fatal error:', error);
+	process.exit(1);
+});