node-mac-recorder 2.22.23 → 2.22.32

package/binding.gyp

@@ -11,7 +11,6 @@
         "src/audio_recorder.mm",
         "src/audio_mixer.mm",
         "src/cursor_tracker.mm",
-        "src/text_input_ax_snapshot.mm",
         "src/window_selector.mm"
       ],
       "include_dirs": [

package/electron-safe-binding.gyp

@@ -7,7 +7,6 @@
         "src/electron_safe/screen_capture_electron.mm",
         "src/electron_safe/audio_capture_electron.mm",
         "src/electron_safe/cursor_tracker_electron.mm",
-        "src/text_input_ax_snapshot.mm",
         "src/electron_safe/window_selector_electron.mm"
       ],
       "include_dirs": [

package/electron-safe-index.js

@@ -1,7 +1,6 @@
 const { EventEmitter } = require("events");
 const path = require("path");
 const fs = require("fs");
-const cursorCapturePolling = require("./lib/cursorCapture/polling");
 
 // Electron-safe native module loading
 let electronSafeNativeBinding;
@@ -42,17 +41,6 @@ class ElectronSafeMacRecorder extends EventEmitter {
 		this.recordingTimer = null;
 		this.recordingStartTime = null;
 
-		this.cursorCaptureInterval = null;
-		this.cursorCaptureFile = null;
-		this.cursorCaptureStartTime = null;
-		this.cursorCaptureFirstWrite = true;
-		this.lastCapturedData = null;
-		this.cursorDisplayInfo = null;
-		this.recordingDisplayInfo = null;
-		this.cursorCaptureSessionTimestamp = null;
-		this.sessionTimestamp = null;
-		this.syncTimestamp = null;
-
 		this.options = {
 			includeMicrophone: false,
 			includeSystemAudio: false,
@@ -97,8 +85,10 @@ class ElectronSafeMacRecorder extends EventEmitter {
 			throw new Error("Output path is required");
 		}
 
+		// Update options
 		this.setOptions(options);
 
+		// Ensure output directory exists
 		const outputDir = path.dirname(outputPath);
 		if (!fs.existsSync(outputDir)) {
 			fs.mkdirSync(outputDir, { recursive: true });
@@ -106,123 +96,63 @@ class ElectronSafeMacRecorder extends EventEmitter {
 
 		this.outputPath = outputPath;
 
-		console.log("🎬 Starting Electron-safe recording...");
-		console.log("📁 Output path:", outputPath);
-		console.log("⚙️ Options:", this.options);
-
-		const startTimeout = setTimeout(() => {
-			this.isRecording = false;
-		}, 10000);
-
-		let success = false;
-		try {
-			success = electronSafeNativeBinding.startRecording(
-				outputPath,
-				this.options,
-			);
-		} finally {
-			clearTimeout(startTimeout);
-		}
-
-		if (!success) {
-			console.error("❌ Failed to start Electron-safe recording");
-			throw new Error("Failed to start recording - check permissions");
-		}
-
-		this.isRecording = true;
-		this.recordingStartTime = Date.now();
-
-		this.recordingTimer = setInterval(() => {
-			const elapsed = Math.floor(
-				(Date.now() - this.recordingStartTime) / 1000,
-			);
-			this.emit("timeUpdate", elapsed);
-		}, 1000);
-
-		const sessionTs =
-			options.sessionTimestamp ||
-			this.sessionTimestamp ||
-			this.recordingStartTime;
-		this.sessionTimestamp = sessionTs;
-		const cursorFilePath = path.join(
-			outputDir,
-			`temp_cursor_${sessionTs}.json`,
-		);
-
-		let recordingDisplayInfo = null;
-		try {
-			const displays = await this.getDisplays();
-			const did = this.options.displayId;
-			let target = null;
-			if (did != null && did !== undefined) {
-				target = displays.find((d) => d.id === did);
-			}
-			if (!target) {
-				target = displays.find((d) => d.isPrimary) || displays[0];
-			}
-			if (target) {
-				recordingDisplayInfo = {
-					displayId: target.id,
-					x: target.x || 0,
-					y: target.y || 0,
-					width: target.width,
-					height: target.height,
-					logicalWidth: target.width,
-					logicalHeight: target.height,
-				};
+		return new Promise((resolve, reject) => {
+			try {
+				console.log("🎬 Starting Electron-safe recording...");
+				console.log("📁 Output path:", outputPath);
+				console.log("⚙️ Options:", this.options);
+
+				// Call native function with timeout protection
+				const startTimeout = setTimeout(() => {
+					this.isRecording = false;
+					reject(new Error("Recording start timeout - Electron protection"));
+				}, 10000); // 10 second timeout
+
+				const success = electronSafeNativeBinding.startRecording(
+					outputPath,
+					this.options
+				);
+				clearTimeout(startTimeout);
+
+				if (success) {
+					this.isRecording = true;
+					this.recordingStartTime = Date.now();
+
+					// Start progress timer
+					this.recordingTimer = setInterval(() => {
+						const elapsed = Math.floor(
+							(Date.now() - this.recordingStartTime) / 1000
+						);
+						this.emit("timeUpdate", elapsed);
+					}, 1000);
+
+					// Emit started event
+					setTimeout(() => {
+						this.emit("recordingStarted", {
+							outputPath: this.outputPath,
+							timestamp: this.recordingStartTime,
+							options: this.options,
+							electronSafe: true,
+						});
+					}, 100);
+
+					this.emit("started", this.outputPath);
+					console.log("✅ Electron-safe recording started successfully");
+					resolve(this.outputPath);
+				} else {
+					console.error("❌ Failed to start Electron-safe recording");
+					reject(new Error("Failed to start recording - check permissions"));
+				}
+			} catch (error) {
+				console.error("❌ Exception during recording start:", error);
+				this.isRecording = false;
+				if (this.recordingTimer) {
+					clearInterval(this.recordingTimer);
+					this.recordingTimer = null;
+				}
+				reject(error);
 			}
-		} catch {
-			recordingDisplayInfo = null;
-		}
-		this.recordingDisplayInfo = recordingDisplayInfo;
-
-		const syncTimestamp = Date.now();
-		this.syncTimestamp = syncTimestamp;
-
-		try {
-			await cursorCapturePolling.startCursorCapture(
-				this,
-				electronSafeNativeBinding,
-				cursorFilePath,
-				{
-					videoRelative: !!recordingDisplayInfo,
-					displayInfo: recordingDisplayInfo,
-					recordingType: this.options.windowId
-						? "window"
-						: this.options.captureArea
-							? "area"
-							: "display",
-					captureArea: this.options.captureArea || null,
-					windowId: this.options.windowId || null,
-					startTimestamp: syncTimestamp,
-				},
-			);
-		} catch (cursorError) {
-			console.warn(
-				"⚠️ Cursor tracking failed to start:",
-				cursorError.message,
-			);
-		}
-
-		const startPayloadTs = this.syncTimestamp || this.recordingStartTime;
-		const fileTimestampPayload = this.sessionTimestamp;
-
-		setTimeout(() => {
-			this.emit("recordingStarted", {
-				outputPath: this.outputPath,
-				timestamp: startPayloadTs,
-				options: this.options,
-				electronSafe: true,
-				cursorOutputPath: cursorFilePath,
-				sessionTimestamp: fileTimestampPayload,
-				syncTimestamp: startPayloadTs,
-				fileTimestamp: fileTimestampPayload,
-			});
-		}, 100);
-
-		this.emit("started", this.outputPath);
-		console.log("✅ Electron-safe recording started successfully");
-		return this.outputPath;
+		});
 	}
 
 	/**
@@ -233,66 +163,64 @@ class ElectronSafeMacRecorder extends EventEmitter {
 			throw new Error("No recording in progress");
 		}
 
-		try {
-			console.log("🛑 Stopping Electron-safe recording...");
-
-			if (this.cursorCaptureInterval) {
-				try {
-					await cursorCapturePolling.stopCursorCapture(this);
-				} catch (cursorErr) {
-					console.warn(
-						"⚠️ Cursor capture stop:",
-						cursorErr.message,
-					);
-				}
-			}
+		return new Promise((resolve, reject) => {
+			try {
+				console.log("🛑 Stopping Electron-safe recording...");
+
+				// Call native function with timeout protection
+				const stopTimeout = setTimeout(() => {
+					this.isRecording = false;
+					if (this.recordingTimer) {
+						clearInterval(this.recordingTimer);
+						this.recordingTimer = null;
+					}
+					reject(new Error("Recording stop timeout - forced cleanup"));
+				}, 10000); // 10 second timeout
+
+				const success = electronSafeNativeBinding.stopRecording();
+				clearTimeout(stopTimeout);
 
-			const stopTimeout = setTimeout(() => {
+				// Always cleanup
 				this.isRecording = false;
 				if (this.recordingTimer) {
 					clearInterval(this.recordingTimer);
 					this.recordingTimer = null;
 				}
-			}, 10000);
 
-			const success = electronSafeNativeBinding.stopRecording();
-			clearTimeout(stopTimeout);
-
-			this.isRecording = false;
-			if (this.recordingTimer) {
-				clearInterval(this.recordingTimer);
-				this.recordingTimer = null;
-			}
+				const result = {
+					code: success ? 0 : 1,
+					outputPath: this.outputPath,
+					electronSafe: true,
+				};
 
-			const result = {
-				code: success ? 0 : 1,
-				outputPath: this.outputPath,
-				electronSafe: true,
-			};
+				this.emit("stopped", result);
+
+				if (success) {
+					// Check if file exists
+					setTimeout(() => {
+						if (fs.existsSync(this.outputPath)) {
+							this.emit("completed", this.outputPath);
+							console.log("✅ Recording completed successfully");
+						} else {
+							console.warn("⚠️ Recording completed but file not found");
+						}
+					}, 1000);
+				}
 
-			this.emit("stopped", result);
+				resolve(result);
+			} catch (error) {
+				console.error("❌ Exception during recording stop:", error);
 
-			if (success) {
-				setTimeout(() => {
-					if (fs.existsSync(this.outputPath)) {
-						this.emit("completed", this.outputPath);
-						console.log("✅ Recording completed successfully");
-					} else {
-						console.warn("⚠️ Recording completed but file not found");
-					}
-				}, 1000);
-			}
+				// Force cleanup
+				this.isRecording = false;
+				if (this.recordingTimer) {
+					clearInterval(this.recordingTimer);
+					this.recordingTimer = null;
+				}
 
-			return result;
-		} catch (error) {
-			console.error("❌ Exception during recording stop:", error);
-			this.isRecording = false;
-			if (this.recordingTimer) {
-				clearInterval(this.recordingTimer);
-				this.recordingTimer = null;
+				reject(error);
 			}
-			throw error;
-		}
+		});
 	}
 
 	/**
@@ -452,26 +380,6 @@ class ElectronSafeMacRecorder extends EventEmitter {
 		}
 	}
 
-	async startCursorCapture(intervalOrFilepath, options = {}) {
-		if (!loadElectronSafeModule()) {
-			throw new Error("Failed to load Electron-safe native module");
-		}
-		return cursorCapturePolling.startCursorCapture(
-			this,
-			electronSafeNativeBinding,
-			intervalOrFilepath,
-			options,
-		);
-	}
-
-	async stopCursorCapture() {
-		loadElectronSafeModule();
-		if (!electronSafeNativeBinding) {
-			return false;
-		}
-		return cursorCapturePolling.stopCursorCapture(this);
-	}
-
 	/**
 	 * Get module information
 	 */