node-mac-recorder 2.24.10 → 2.24.12

package/MultiWindowRecorder.js

@@ -15,6 +15,9 @@ class MultiWindowRecorder extends EventEmitter {
         this.recorders = [];
         this.windows = [];
         this.isRecording = false;
+        this.isPaused = false;
+        this.pauseStartedAt = null;
+        this.pausedDurationMs = 0;
         this.outputFiles = [];
         this.cursorFiles = [];
         this.cameraFile = null; // Camera output file (from first recorder)
@@ -51,6 +54,11 @@ class MultiWindowRecorder extends EventEmitter {
      */
     async addWindow(windowInfo) {
         const recorder = new MacRecorder();
+        // Child-process errors use EventEmitter's special "error" event.
+        // Listen before the worker can fail (including during addWindow).
+        recorder.on('error', (error) => {
+            this.emit('recorderError', { windowId: windowInfo.id, error: error.message });
+        });
 
         const recorderInfo = {
             recorder,
@@ -255,8 +263,9 @@ class MultiWindowRecorder extends EventEmitter {
             } catch (error) {
                 console.error(`   ❌ Failed to start recorder ${i + 1}:`, error.message);
 
-                // Stop all previously started recorders and cursor tracking
-                for (let j = 0; j < i; j++) {
+                // Cursor setup can fail AFTER the current video started.
+                // Reclaim that recorder too, not just previous windows.
+                for (let j = 0; j <= i; j++) {
                     try {
                         await this.recorders[j].recorder.stopRecording();
                     } catch (stopError) {
@@ -282,7 +291,7 @@ class MultiWindowRecorder extends EventEmitter {
         // Start timeUpdate timer (emit every second)
         this.timeUpdateInterval = setInterval(() => {
             if (this.isRecording && this.metadata.startTime) {
-                const elapsed = Math.floor((Date.now() - this.metadata.startTime) / 1000);
+                const elapsed = this._getRecordingTimeSeconds();
                 this.emit('timeUpdate', elapsed);
             }
         }, 1000);
@@ -303,6 +312,66 @@ class MultiWindowRecorder extends EventEmitter {
         };
     }
 
+    _getPausedDurationMs(now = Date.now()) {
+        return this.pausedDurationMs +
+            (this.isPaused && this.pauseStartedAt ? Math.max(0, now - this.pauseStartedAt) : 0);
+    }
+
+    _getRecordingTimeSeconds(now = Date.now()) {
+        if (!this.metadata.startTime) return 0;
+        return Math.floor(Math.max(0, now - this.metadata.startTime - this._getPausedDurationMs(now)) / 1000);
+    }
+
+    async pauseRecording() {
+        if (!this.isRecording) throw new Error('No recording in progress');
+        if (this.isPaused) return this.getStatus();
+
+        const pauseResults = await Promise.allSettled(
+            this.recorders.map(recInfo => recInfo.recorder.pauseRecording())
+        );
+        const pauseFailure = pauseResults.find(result => result.status === 'rejected');
+        if (pauseFailure) {
+            const pausedRecorders = this.recorders
+                .filter((_, index) => pauseResults[index].status === 'fulfilled')
+                .map(recInfo => recInfo.recorder);
+            await Promise.allSettled(pausedRecorders.map(recorder => recorder.resumeRecording()));
+            throw pauseFailure.reason;
+        }
+
+        const pausedAt = Date.now();
+        this.cursorRecorder?.pauseCursorCapture?.(pausedAt);
+        this.isPaused = true;
+        this.pauseStartedAt = pausedAt;
+        const status = this.getStatus();
+        this.emit('paused', status);
+        return status;
+    }
+
+    async resumeRecording() {
+        if (!this.isRecording) throw new Error('No recording in progress');
+        if (!this.isPaused) return this.getStatus();
+
+        const resumeResults = await Promise.allSettled(
+            this.recorders.map(recInfo => recInfo.recorder.resumeRecording())
+        );
+        const resumeFailure = resumeResults.find(result => result.status === 'rejected');
+        if (resumeFailure) {
+            const resumedRecorders = this.recorders
+                .filter((_, index) => resumeResults[index].status === 'fulfilled')
+                .map(recInfo => recInfo.recorder);
+            await Promise.allSettled(resumedRecorders.map(recorder => recorder.pauseRecording()));
+            throw resumeFailure.reason;
+        }
+        const resumedAt = Date.now();
+        this.cursorRecorder?.resumeCursorCapture?.(resumedAt);
+        this.pausedDurationMs += Math.max(0, resumedAt - this.pauseStartedAt);
+        this.pauseStartedAt = null;
+        this.isPaused = false;
+        const status = this.getStatus();
+        this.emit('resumed', status);
+        return status;
+    }
+
     /**
      * Stop all recordings
      */
@@ -392,7 +461,8 @@ class MultiWindowRecorder extends EventEmitter {
         }
 
         // Calculate duration
-        const duration = stopTimestamp - this.metadata.startTime;
+        const pausedDuration = this._getPausedDurationMs(stopTimestamp);
+        const duration = Math.max(0, stopTimestamp - this.metadata.startTime - pausedDuration);
 
         const result = {
             success: results.every(r => r.success),
@@ -402,6 +472,7 @@ class MultiWindowRecorder extends EventEmitter {
             cameraFile: this.cameraFile, // Camera output path (from first recorder)
             audioFile: this.audioFile,   // Audio output path (from first recorder)
             duration: duration,
+            pausedDuration,
             metadata: {
                 ...this.metadata,
                 stopTime: stopTimestamp,
@@ -426,6 +497,10 @@ class MultiWindowRecorder extends EventEmitter {
 
         this.emit('allStopped', result);
 
+        this.isPaused = false;
+        this.pauseStartedAt = null;
+        this.pausedDurationMs = 0;
+
         return result;
     }
 
@@ -435,6 +510,9 @@ class MultiWindowRecorder extends EventEmitter {
     getStatus() {
         return {
             isRecording: this.isRecording,
+            isPaused: this.isPaused,
+            recordingTime: this._getRecordingTimeSeconds(),
+            pausedDuration: this._getPausedDurationMs() / 1000,
             windowCount: this.recorders.length,
             outputFiles: this.outputFiles,
             metadata: this.metadata,
@@ -538,6 +616,9 @@ class MultiWindowRecorder extends EventEmitter {
         this.outputFiles = [];
         this.cursorFiles = [];
         this.isRecording = false;
+        this.isPaused = false;
+        this.pauseStartedAt = null;
+        this.pausedDurationMs = 0;
 
         console.log('✅ Multi-window recorder cleaned up');
     }

package/README.md

@@ -188,6 +188,21 @@ await recorder.startRecording("./recording.mov", {
 });
 ```
 
+#### `pauseRecording()` / `resumeRecording()`
+
+Pauses every active track without closing the output files, then resumes the
+same recording session. Time spent paused is removed from the screen, camera,
+audio, cursor, and keyboard timelines.
+
+```javascript
+await recorder.pauseRecording();
+// The output writers remain open while paused.
+await recorder.resumeRecording();
+```
+
+Both calls are idempotent and emit `paused` / `resumed` events with the current
+status. `stopRecording()` may also be called while paused.
+
 #### `stopRecording()`
 
 Stops the current recording.
@@ -334,6 +349,7 @@ const status = recorder.getStatus();
 console.log(status);
 // {
 //   isRecording: true,
+//   isPaused: false,
 //   outputPath: "./recording.mov",
 //   cameraOutputPath: "./temp_camera_1720000000000.webm",
 //   audioOutputPath: "./temp_audio_1720000000000.webm",
@@ -341,7 +357,8 @@ console.log(status);
 //   audioCapturing: true,
 //   sessionTimestamp: 1720000000000,
 //   options: { ... },
-//   recordingTime: 15
+//   recordingTime: 15,
+//   pausedDuration: 3.5
 // }
 ```
 

package/binding.gyp

@@ -44,7 +44,8 @@
           "-framework Carbon",
           "-framework Accessibility",
           "-framework CoreAudio",
-          "-framework CoreMediaIO"
+          "-framework CoreMediaIO",
+          "-framework IOKit"
         ]
       },
       "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ]

package/index-multiprocess.js

@@ -13,6 +13,7 @@ class MacRecorderMultiProcess extends EventEmitter {
 
         this.worker = null;
         this.isRecording = false;
+        this.isPaused = false;
         this.outputPath = null;
         this.ready = false;
         this.pendingRequests = new Map();
@@ -36,6 +37,8 @@ class MacRecorderMultiProcess extends EventEmitter {
 
         this.worker.on('error', (error) => {
             console.error('❌ Worker error:', error);
+            for (const { reject } of this.pendingRequests.values()) reject(error);
+            this.pendingRequests.clear();
             this.emit('error', error);
         });
 
@@ -43,6 +46,7 @@ class MacRecorderMultiProcess extends EventEmitter {
             console.log(`🛑 Worker exited: code=${code}, signal=${signal}`);
             this.ready = false;
             this.isRecording = false;
+            this.isPaused = false;
 
             // Reject all pending requests
             for (const [id, { reject }] of this.pendingRequests) {
@@ -75,8 +79,13 @@ class MacRecorderMultiProcess extends EventEmitter {
             // Update local state based on events
             if (msg.event === 'recordingStarted') {
                 this.isRecording = true;
+            } else if (msg.event === 'paused') {
+                this.isPaused = true;
+            } else if (msg.event === 'resumed') {
+                this.isPaused = false;
             } else if (msg.event === 'stopped') {
                 this.isRecording = false;
+                this.isPaused = false;
             }
             return;
         }
@@ -84,7 +93,10 @@ class MacRecorderMultiProcess extends EventEmitter {
         // Handle errors
         if (msg.type === 'error') {
             console.error('❌ Worker error:', msg.message);
-            this.emit('error', new Error(msg.message));
+            const error = new Error(msg.message);
+            for (const { reject } of this.pendingRequests.values()) reject(error);
+            this.pendingRequests.clear();
+            this.emit('error', error);
             return;
         }
 
@@ -110,7 +122,7 @@ class MacRecorderMultiProcess extends EventEmitter {
 
     _sendRequest(type, data = null, timeout = 30000) {
         return new Promise((resolve, reject) => {
-            if (!this.worker) {
+            if (!this.worker || !this.worker.connected) {
                 return reject(new Error('Worker not initialized'));
             }
 
@@ -131,9 +143,6 @@ class MacRecorderMultiProcess extends EventEmitter {
                 }
             }, timeout);
 
-            // Send message to worker
-            this.worker.send({ type, data, id });
-
             // Clear timeout on completion
             const originalResolve = resolve;
             const originalReject = reject;
@@ -149,6 +158,16 @@ class MacRecorderMultiProcess extends EventEmitter {
                     originalReject(error);
                 }
             });
+
+            // A closed IPC pipe may fail asynchronously. Passing a callback
+            // contains that error and releases the pending request/timer.
+            const sendFailed = (error) => {
+                if (!error) return;
+                this.pendingRequests.get(id)?.reject(error);
+                this.pendingRequests.delete(id);
+            };
+            try { this.worker.send({ type, data, id }, sendFailed); }
+            catch (error) { sendFailed(error); }
         });
     }
 
@@ -186,16 +205,37 @@ class MacRecorderMultiProcess extends EventEmitter {
             options
         }, 60000); // Longer timeout for recording start
 
+        // The native first-frame event can arrive later than this response.
+        // Stop must already be available during that interval.
+        this.isRecording = true;
+        this.isPaused = false;
         return result.outputPath;
     }
 
+    async pauseRecording() {
+        if (!this.isRecording) throw new Error('No recording in progress');
+        if (this.isPaused) return this.getStatus();
+        const status = await this._sendRequest('pauseRecording');
+        this.isPaused = true;
+        return status;
+    }
+
+    async resumeRecording() {
+        if (!this.isRecording) throw new Error('No recording in progress');
+        if (!this.isPaused) return this.getStatus();
+        const status = await this._sendRequest('resumeRecording');
+        this.isPaused = false;
+        return status;
+    }
+
     async stopRecording() {
         if (!this.isRecording) {
             throw new Error('No recording in progress');
         }
 
-        const result = await this._sendRequest('stopRecording', null, 10000);
+        const result = await this._sendRequest('stopRecording', null, 45000);
         this.isRecording = false;
+        this.isPaused = false;
 
         return result;
     }
@@ -231,6 +271,10 @@ class MacRecorderMultiProcess extends EventEmitter {
 
         this.ready = false;
         this.isRecording = false;
+        this.isPaused = false;
+        for (const { reject } of this.pendingRequests.values()) {
+            reject(new Error('Recorder worker destroyed'));
+        }
         this.pendingRequests.clear();
     }
 }