node-mac-recorder 2.21.40 → 2.21.42

package/index-multiprocess.js

@@ -0,0 +1,238 @@
+/**
+ * Multi-Process MacRecorder
+ * Spawns each recorder in its own child process for true parallel recording
+ */
+
+const { EventEmitter } = require('events');
+const { fork } = require('child_process');
+const path = require('path');
+
+class MacRecorderMultiProcess extends EventEmitter {
+    constructor(options = {}) {
+        super();
+
+        this.worker = null;
+        this.isRecording = false;
+        this.outputPath = null;
+        this.ready = false;
+        this.pendingRequests = new Map();
+        this.requestId = 0;
+
+        // Auto-spawn worker
+        this._spawnWorker();
+    }
+
+    _spawnWorker() {
+        const workerPath = path.join(__dirname, 'recorder-worker.js');
+
+        console.log(`🚀 Spawning recorder worker: ${workerPath}`);
+
+        this.worker = fork(workerPath, [], {
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+            env: { ...process.env }
+        });
+
+        this.worker.on('message', (msg) => this._handleWorkerMessage(msg));
+
+        this.worker.on('error', (error) => {
+            console.error('❌ Worker error:', error);
+            this.emit('error', error);
+        });
+
+        this.worker.on('exit', (code, signal) => {
+            console.log(`🛑 Worker exited: code=${code}, signal=${signal}`);
+            this.ready = false;
+            this.isRecording = false;
+
+            // Reject all pending requests
+            for (const [id, { reject }] of this.pendingRequests) {
+                reject(new Error('Worker process exited'));
+            }
+            this.pendingRequests.clear();
+        });
+
+        this.worker.stdout.on('data', (data) => {
+            console.log(`[Worker] ${data.toString().trim()}`);
+        });
+
+        this.worker.stderr.on('data', (data) => {
+            console.error(`[Worker Error] ${data.toString().trim()}`);
+        });
+    }
+
+    _handleWorkerMessage(msg) {
+        // Handle ready message
+        if (msg.type === 'ready') {
+            this.ready = true;
+            console.log('✅ Worker ready');
+            return;
+        }
+
+        // Handle events
+        if (msg.type === 'event') {
+            this.emit(msg.event, msg.data);
+
+            // Update local state based on events
+            if (msg.event === 'recordingStarted') {
+                this.isRecording = true;
+            } else if (msg.event === 'stopped') {
+                this.isRecording = false;
+            }
+            return;
+        }
+
+        // Handle errors
+        if (msg.type === 'error') {
+            console.error('❌ Worker error:', msg.message);
+            this.emit('error', new Error(msg.message));
+            return;
+        }
+
+        // Handle responses to specific requests
+        if (msg.type.endsWith(':response')) {
+            const requestType = msg.type.replace(':response', '');
+
+            // Find matching pending request
+            for (const [id, { type, resolve, reject }] of this.pendingRequests) {
+                if (type === requestType) {
+                    this.pendingRequests.delete(id);
+
+                    if (msg.success === false) {
+                        reject(new Error(msg.error || 'Request failed'));
+                    } else {
+                        resolve(msg.data);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    _sendRequest(type, data = null, timeout = 30000) {
+        return new Promise((resolve, reject) => {
+            if (!this.worker) {
+                return reject(new Error('Worker not initialized'));
+            }
+
+            if (!this.ready) {
+                return reject(new Error('Worker not ready'));
+            }
+
+            const id = ++this.requestId;
+
+            // Store pending request
+            this.pendingRequests.set(id, { type, resolve, reject });
+
+            // Set timeout
+            const timeoutId = setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`Request timeout: ${type}`));
+                }
+            }, timeout);
+
+            // Send message to worker
+            this.worker.send({ type, data, id });
+
+            // Clear timeout on completion
+            const originalResolve = resolve;
+            const originalReject = reject;
+
+            this.pendingRequests.set(id, {
+                type,
+                resolve: (value) => {
+                    clearTimeout(timeoutId);
+                    originalResolve(value);
+                },
+                reject: (error) => {
+                    clearTimeout(timeoutId);
+                    originalReject(error);
+                }
+            });
+        });
+    }
+
+    async getWindows() {
+        return this._sendRequest('getWindows');
+    }
+
+    async getDisplays() {
+        const displays = await this._sendRequest('getDisplays');
+        return displays.map((display, index) => ({
+            id: display.id,
+            name: display.name,
+            width: display.width,
+            height: display.height,
+            x: display.x,
+            y: display.y,
+            isPrimary: display.isPrimary,
+            resolution: `${display.width}x${display.height}`
+        }));
+    }
+
+    async startRecording(outputPath, options = {}) {
+        if (this.isRecording) {
+            throw new Error('Recording already in progress');
+        }
+
+        if (!outputPath) {
+            throw new Error('Output path is required');
+        }
+
+        this.outputPath = outputPath;
+
+        const result = await this._sendRequest('startRecording', {
+            outputPath,
+            options
+        }, 60000); // Longer timeout for recording start
+
+        return result.outputPath;
+    }
+
+    async stopRecording() {
+        if (!this.isRecording) {
+            throw new Error('No recording in progress');
+        }
+
+        const result = await this._sendRequest('stopRecording', null, 10000);
+        this.isRecording = false;
+
+        return result;
+    }
+
+    async startCursorCapture(filepath, options = {}) {
+        if (!this.ready) {
+            throw new Error('Worker not ready');
+        }
+
+        const result = await this._sendRequest('startCursorCapture', {
+            filepath,
+            options
+        });
+
+        return result;
+    }
+
+    async stopCursorCapture() {
+        const result = await this._sendRequest('stopCursorCapture');
+        return result;
+    }
+
+    async getStatus() {
+        return this._sendRequest('getStatus');
+    }
+
+    // Cleanup
+    destroy() {
+        if (this.worker) {
+            this.worker.kill();
+            this.worker = null;
+        }
+
+        this.ready = false;
+        this.isRecording = false;
+        this.pendingRequests.clear();
+    }
+}
+
+module.exports = MacRecorderMultiProcess;

package/index.js

@@ -2,20 +2,42 @@ const { EventEmitter } = require("events");
 const path = require("path");
 const fs = require("fs");
 
+// Auto-switch to Electron-safe implementation when running under Electron and binary exists
+let USE_ELECTRON_SAFE = false;
+let ElectronSafeMacRecorder = null;
+try {
+  const isElectron = !!(process && process.versions && process.versions.electron);
+  const preferElectronSafe = process.env.PREFER_ELECTRON_SAFE === "1" || process.env.USE_ELECTRON_SAFE === "1";
+  if (isElectron || preferElectronSafe) {
+    const rel = path.join(__dirname, "build", "Release", "mac_recorder_electron.node");
+    const dbg = path.join(__dirname, "build", "Debug", "mac_recorder_electron.node");
+    if (fs.existsSync(rel) || fs.existsSync(dbg) || preferElectronSafe) {
+      // Defer requiring native .node; use JS wrapper which loads it
+      ElectronSafeMacRecorder = require("./electron-safe-index");
+      USE_ELECTRON_SAFE = true;
+      console.log("✅ Auto-enabled Electron-safe MacRecorder");
+    }
+  }
+} catch (_) {
+  // Ignore auto-switch errors; fall back to standard binding
+}
+
 // Native modülü yükle
 let nativeBinding;
-try {
-	nativeBinding = require("./build/Release/mac_recorder.node");
-} catch (error) {
-	try {
-		nativeBinding = require("./build/Debug/mac_recorder.node");
-	} catch (debugError) {
-		throw new Error(
-			'Native module not found. Please run "npm run build" to compile the native module.\n' +
-				"Original error: " +
-				error.message
-		);
-	}
+if (!USE_ELECTRON_SAFE) {
+  try {
+    nativeBinding = require("./build/Release/mac_recorder.node");
+  } catch (error) {
+    try {
+      nativeBinding = require("./build/Debug/mac_recorder.node");
+    } catch (debugError) {
+      throw new Error(
+        'Native module not found. Please run "npm run build" to compile the native module.\n' +
+          "Original error: " +
+          error.message
+      );
+    }
+  }
 }
 
 class MacRecorder extends EventEmitter {
@@ -26,6 +48,9 @@ class MacRecorder extends EventEmitter {
 		this.recordingTimer = null;
 		this.recordingStartTime = null;
 
+		// MULTI-SESSION: Unique session ID for this recorder instance
+		this.nativeSessionId = null;  // Will be generated when recording starts
+
 		// Cursor capture variables
 		this.cursorCaptureInterval = null;
 		this.cursorCaptureFile = null;
@@ -155,6 +180,9 @@ class MacRecorder extends EventEmitter {
 	 */
 	setOptions(options = {}) {
 		// Merge options instead of replacing to preserve previously set values
+		if (options.sessionTimestamp !== undefined) {
+			this.options.sessionTimestamp = options.sessionTimestamp;
+		}
 		if (options.includeMicrophone !== undefined) {
 			this.options.includeMicrophone = options.includeMicrophone === true;
 		}
@@ -189,6 +217,10 @@ class MacRecorder extends EventEmitter {
 				this.options.frameRate = Math.min(Math.max(fps, 1), 120);
 			}
 		}
+		// Prefer ScreenCaptureKit (macOS 15+) toggle
+		if (options.preferScreenCaptureKit !== undefined) {
+			this.options.preferScreenCaptureKit = options.preferScreenCaptureKit === true;
+		}
 		if (options.cameraDeviceId !== undefined) {
 			this.options.cameraDeviceId =
 				typeof options.cameraDeviceId === "string" && options.cameraDeviceId.length > 0
@@ -448,9 +480,18 @@ class MacRecorder extends EventEmitter {
 
 		return new Promise(async (resolve, reject) => {
 			try {
-				// SYNC FIX: Create unified session timestamp FIRST for all components
-				const sessionTimestamp = Date.now();
+				// MULTI-SESSION: Generate unique session ID for this recording
+				// Use provided sessionTimestamp from options, or generate new one
+				const sessionTimestamp = this.options.sessionTimestamp || Date.now();
 				this.sessionTimestamp = sessionTimestamp;
+				this.nativeSessionId = `rec_${sessionTimestamp}_${Math.random().toString(36).substr(2, 9)}`;
+
+				console.log(`🎬 Starting recording with session ID: ${this.nativeSessionId}`);
+				if (this.options.sessionTimestamp) {
+					console.log(`   ⏰ Using provided sessionTimestamp: ${this.options.sessionTimestamp}`);
+				} else {
+					console.log(`   ⏰ Generated new sessionTimestamp: ${sessionTimestamp}`);
+				}
 
 				// CRITICAL FIX: Ensure main video file also uses sessionTimestamp
 				// This guarantees ALL files have the exact same timestamp
@@ -505,8 +546,12 @@ class MacRecorder extends EventEmitter {
 					captureCamera: this.options.captureCamera === true,
 					cameraDeviceId: this.options.cameraDeviceId || null,
 					sessionTimestamp,
+					// MULTI-SESSION: Pass unique session ID to native code
+					nativeSessionId: this.nativeSessionId,
 					frameRate: this.options.frameRate || 60,
 					quality: this.options.quality || "high",
+					// Hint native side to use ScreenCaptureKit on macOS 15+
+					preferScreenCaptureKit: this.options.preferScreenCaptureKit === true,
 				};
 
 					if (cameraFilePath) {
@@ -554,10 +599,34 @@ class MacRecorder extends EventEmitter {
 
 				// Only start cursor if native recording started successfully
 				if (success) {
+					// For ScreenCaptureKit (async startup), wait briefly until native fully initialized
+					// ScreenCaptureKit needs ~150-300ms to start + ~150ms for first 10 frames
+					const waitStart = Date.now();
+					try {
+						while (Date.now() - waitStart < 600) {
+							try {
+								const nativeStatus = nativeBinding && nativeBinding.getRecordingStatus ? nativeBinding.getRecordingStatus() : true;
+								if (nativeStatus) {
+									console.log(`✅ SYNC: Native recording fully ready after ${Date.now() - waitStart}ms`);
+									break;
+								}
+							} catch (_) {}
+							await new Promise(r => setTimeout(r, 30));
+						}
+					} catch (_) {}
 					this.sessionTimestamp = sessionTimestamp;
+
+					// CURSOR SYNC FIX: Wait additional 300ms for first frames to start
+					// This ensures cursor tracking aligns with actual video timeline
+					// ScreenCaptureKit needs ~200-350ms to actually start capturing frames
+					// We wait 300ms to ensure cursor starts AFTER first video frame
+					console.log('⏳ CURSOR SYNC: Waiting 300ms for first video frames...');
+					await new Promise(r => setTimeout(r, 300));
+
 					const syncTimestamp = Date.now();
 					this.syncTimestamp = syncTimestamp;
 					this.recordingStartTime = syncTimestamp;
+					console.log(`🎯 CURSOR SYNC: Cursor tracking will use timestamp: ${syncTimestamp}`);
 
 					const standardCursorOptions = {
 						videoRelative: true,
@@ -1100,6 +1169,27 @@ class MacRecorder extends EventEmitter {
 		// SYNC FIX: Use pre-defined timestamp if provided for synchronization
 		const syncStartTime = options.startTimestamp || Date.now();
 
+		// Fetch window bounds for multi-window recording
+		if (options.multiWindowBounds && options.multiWindowBounds.length > 0) {
+			try {
+				const allWindows = await this.getWindows();
+				// Match window IDs and populate bounds
+				for (const windowInfo of options.multiWindowBounds) {
+					const windowData = allWindows.find(w => w.id === windowInfo.windowId);
+					if (windowData) {
+						windowInfo.bounds = {
+							x: windowData.x || 0,
+							y: windowData.y || 0,
+							width: windowData.width || 0,
+							height: windowData.height || 0
+						};
+					}
+				}
+			} catch (error) {
+				console.warn('Failed to fetch window bounds for multi-window cursor tracking:', error.message);
+			}
+		}
+
 		// Use video-relative coordinate system for all recording types
 		if (options.videoRelative && options.displayInfo) {
 			// Calculate video offset based on recording type
@@ -1139,7 +1229,9 @@ class MacRecorder extends EventEmitter {
 				recordingType: options.recordingType || 'display',
 				// Store additional context for debugging
 				captureArea: options.captureArea,
-				windowId: options.windowId
+				windowId: options.windowId,
+				// Multi-window bounds for location detection
+				multiWindowBounds: options.multiWindowBounds || null
 			};
 		} else if (this.recordingDisplayInfo) {
 			// Fallback: Use recording display info if available
@@ -1154,7 +1246,8 @@ class MacRecorder extends EventEmitter {
 				videoWidth: this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
 				videoHeight: this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
 				videoRelative: true,
-				recordingType: options.recordingType || 'display'
+				recordingType: options.recordingType || 'display',
+				multiWindowBounds: options.multiWindowBounds || null
 			};
 		} else {
 			// Final fallback: Main display global coordinates
@@ -1168,6 +1261,7 @@ class MacRecorder extends EventEmitter {
 						y: mainDisplay.y,
 						width: parseInt(mainDisplay.resolution.split("x")[0]),
 						height: parseInt(mainDisplay.resolution.split("x")[1]),
+						multiWindowBounds: options.multiWindowBounds || null
 					};
 				}
 			} catch (error) {
@@ -1187,6 +1281,8 @@ class MacRecorder extends EventEmitter {
 				this.cursorCaptureStartTime = syncStartTime;
 				this.cursorCaptureFirstWrite = true;
 				this.lastCapturedData = null;
+				// Store session timestamp for sync metadata
+				this.cursorCaptureSessionTimestamp = this.sessionTimestamp;
 
 				// JavaScript interval ile polling yap (daha sık - mouse event'leri yakalamak için)
 				this.cursorCaptureInterval = setInterval(() => {
@@ -1236,14 +1332,73 @@ class MacRecorder extends EventEmitter {
 								height: this.cursorDisplayInfo.videoHeight,
 								offsetX: this.cursorDisplayInfo.videoOffsetX,
 								offsetY: this.cursorDisplayInfo.videoOffsetY
-							} : null,
+							} : {},
 							displayInfo: this.cursorDisplayInfo ? {
 								displayId: this.cursorDisplayInfo.displayId,
 								width: this.cursorDisplayInfo.displayWidth,
 								height: this.cursorDisplayInfo.displayHeight
-							} : null
+							} : {}
 						};
 
+						// Multi-window location detection with window-relative coordinates
+						if (this.cursorDisplayInfo?.multiWindowBounds && this.cursorDisplayInfo.multiWindowBounds.length > 0) {
+							const location = { hover: null, click: null };
+							let windowRelativeCoords = null;
+
+							// Detect which window the cursor is over
+							for (const windowInfo of this.cursorDisplayInfo.multiWindowBounds) {
+								if (windowInfo.bounds) {
+									const { x: wx, y: wy, width: ww, height: wh } = windowInfo.bounds;
+									// Check if cursor is inside window bounds (using global coordinates)
+									if (position.x >= wx && position.x <= wx + ww &&
+										position.y >= wy && position.y <= wy + wh) {
+										location.hover = windowInfo.windowId;
+
+										// Calculate window-relative coordinates
+										// These coords are relative to the window's top-left corner (0,0)
+										// This allows the desktop app to position cursor correctly
+										// regardless of where the window is placed on canvas
+										windowRelativeCoords = {
+											windowId: windowInfo.windowId,
+											x: position.x - wx,
+											y: position.y - wy,
+											// Also include window dimensions for reference
+											windowWidth: ww,
+											windowHeight: wh
+										};
+
+										// If this is a click event, mark click location
+										// Native eventType values: 'mousedown', 'mouseup', 'rightmousedown', 'rightmouseup'
+										const eventType = position.eventType || '';
+										if (eventType === 'mousedown' ||
+											eventType === 'mouseup' ||
+											eventType === 'rightmousedown' ||
+											eventType === 'rightmouseup') {
+											location.click = windowInfo.windowId;
+										}
+										break; // Found the window, stop searching
+									}
+								}
+							}
+
+							// Add location info to cursor data
+							cursorData.location = location;
+
+							// Add window-relative coordinates if cursor is over a window
+							if (windowRelativeCoords) {
+								cursorData.windowRelative = windowRelativeCoords;
+							}
+						}
+
+						// Add sync metadata to first event only
+						if (this.cursorCaptureFirstWrite && this.cursorCaptureSessionTimestamp) {
+							cursorData._syncMetadata = {
+								videoStartTime: this.cursorCaptureSessionTimestamp,
+								cursorStartTime: this.cursorCaptureStartTime,
+								offsetMs: this.cursorCaptureStartTime - this.cursorCaptureSessionTimestamp
+							};
+						}
+
 						// Sadece eventType değiştiğinde veya pozisyon değiştiğinde kaydet
 						if (this.shouldCaptureEvent(cursorData)) {
 							// Dosyaya ekle
@@ -1519,4 +1674,4 @@ class MacRecorder extends EventEmitter {
 // WindowSelector modülünü de export edelim
 MacRecorder.WindowSelector = require('./window-selector');
 
-module.exports = MacRecorder;
+module.exports = USE_ELECTRON_SAFE ? ElectronSafeMacRecorder : MacRecorder;

package/package.json

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