node-mac-recorder 2.24.10 → 2.24.12

package/src/keyboard_tracker.mm

@@ -11,6 +11,7 @@
 #import <CoreGraphics/CoreGraphics.h>
 #import <Carbon/Carbon.h>
 #import "logging.h"
+#import "sync_timeline.h"
 
 // ---- Global durum (tek aktif oturum) --------------------------------------
 static CFMachPortRef g_kbEventTap = NULL;
@@ -110,6 +111,10 @@ static CGEventRef KeyboardEventCallback(CGEventTapProxy proxy,
         return event;
     }
 
+    if (MRSyncIsPaused()) {
+        return event;
+    }
+
     @autoreleasepool {
         CGEventFlags flags = CGEventGetFlags(event);
         BOOL hasCommand = (flags & kCGEventFlagMaskCommand) != 0;
@@ -146,7 +151,9 @@ static CGEventRef KeyboardEventCallback(CGEventTapProxy proxy,
         }
 
         double unixMs = NowUnixMs();
-        double relMs = g_kbStartUnixMs > 0 ? (unixMs - g_kbStartUnixMs) : 0.0;
+        double relMs = g_kbStartUnixMs > 0
+            ? (unixMs - g_kbStartUnixMs - (MRSyncGetPausedDurationSeconds() * 1000.0))
+            : 0.0;
         if (relMs < 0) relMs = 0;
 
         NSString *json = [NSString stringWithFormat:

package/src/mac_recorder.mm

@@ -25,12 +25,19 @@ extern "C" {
                                    NSString* qualityPreset);
     bool stopAVFoundationRecording();
     bool isAVFoundationRecording();
+    bool hasAVFoundationRecordingResources();
+    bool isAVFoundationRecordingStopping();
     NSString* getAVFoundationAudioPath();
 
     NSArray<NSDictionary *> *listCameraDevices();
     bool startCameraRecording(NSString *outputPath, NSString *deviceId, NSError **error);
     bool stopCameraRecording();
     bool isCameraRecording();
+    bool isCameraRecordingStopping();
+    bool hasCameraRecordingResources();
+    bool isIOSDeviceRecording();
+    bool isIOSDeviceRecordingPending();
+    bool isIOSDeviceRecordingStopping();
     NSString *currentCameraRecordingPath();
     bool waitForCameraRecordingStart(double timeoutSeconds);
     double currentCameraRecordingStartTime(void);
@@ -85,7 +92,8 @@ static double MRComputeElapsedRecordingSeconds(void) {
     if (!g_hasRecordingStartTime) {
         return -1.0;
     }
-    CFTimeInterval elapsed = CFAbsoluteTimeGetCurrent() - g_recordingStartTime;
+    CFTimeInterval elapsed = CFAbsoluteTimeGetCurrent() - g_recordingStartTime
+        - MRSyncGetPausedDurationSeconds();
     if (elapsed <= 0.0) {
         return -1.0;
     }
@@ -218,11 +226,11 @@ void cleanupRecording() {
     }
     
     // AVFoundation cleanup (supports both Node.js and Electron)
-    if (isAVFoundationRecording()) {
+    if (hasAVFoundationRecordingResources()) {
         stopAVFoundationRecording();
     }
 
-    if (isCameraRecording()) {
+    if (hasCameraRecordingResources()) {
         stopCameraRecording();
     }
     if (isStandaloneAudioRecording()) {
@@ -240,11 +248,20 @@ void cleanupRecording() {
 Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
-    if (info.Length() < 1) {
+    if (info.Length() < 1 || !info[0].IsString()) {
         Napi::TypeError::New(env, "Output path required").ThrowAsJavaScriptException();
         return env.Null();
     }
     
+    // Do not tear down an active/pending capture from another invocation.
+    if (isCameraRecordingStopping() || isIOSDeviceRecordingPending() || isAVFoundationRecording() || isAVFoundationRecordingStopping()) {
+        return Napi::Boolean::New(env, false);
+    }
+    if (@available(macOS 12.3, *)) {
+        if ([ScreenCaptureKitRecorder isRecording] || [ScreenCaptureKitRecorder isScheduling] ||
+            [ScreenCaptureKitRecorder isCleaningUp]) return Napi::Boolean::New(env, false);
+    }
+
     // IMPORTANT: Clean up any stale recording state before starting
     // This fixes the issue where macOS 14/13 users get "recording already in progress"
     MRLog(@"🧹 Cleaning up any previous recording state...");
@@ -863,11 +880,12 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
 
     // Try ScreenCaptureKit first
     if (@available(macOS 12.3, *)) {
-        if ([ScreenCaptureKitRecorder isRecording]) {
+        if ([ScreenCaptureKitRecorder isRecording] || [ScreenCaptureKitRecorder isScheduling] ||
+            [ScreenCaptureKitRecorder isCleaningUp]) {
             MRLog(@"🛑 Stopping ScreenCaptureKit recording");
 
             // CRITICAL FIX: Stop camera and audio FIRST (they are synchronous)
-            if (isCameraRecording()) {
+            if (hasCameraRecordingResources()) {
                 MRLog(@"🛑 Stopping camera recording...");
                 bool cameraStopped = stopCameraRecording();
                 if (cameraStopped) {
@@ -878,7 +896,7 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
             }
 
             // Stop standalone microphone if it was used (macOS 13/14)
-            if (g_usingStandaloneAudio && isStandaloneAudioRecording()) {
+            if (g_usingStandaloneAudio) {
                 MRLog(@"🛑 Stopping standalone microphone recording...");
                 bool micStopped = stopStandaloneAudioRecording();
                 if (micStopped) {
@@ -894,8 +912,8 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
             // It will set g_isRecording = NO in its completion handler
             [ScreenCaptureKitRecorder stopRecording];
 
-            // DO NOT set g_isRecording here - let ScreenCaptureKit completion handler do it
-            // Otherwise we have a race condition where JS thinks recording stopped but it's still running
+            // Native lifecycle status separately reports asynchronous cleanup.
+            g_isRecording = false;
             g_usingStandaloneAudio = false;
             return Napi::Boolean::New(env, true);
         }
@@ -907,11 +925,11 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     extern NSString* getAVFoundationAudioPath();
     
     @try {
-        if (isAVFoundationRecording()) {
+        if (hasAVFoundationRecordingResources()) {
             MRLog(@"🛑 Stopping AVFoundation recording");
 
-            BOOL cameraWasRecording = isCameraRecording();
-            BOOL audioWasRecording = g_usingStandaloneAudio && isStandaloneAudioRecording();
+            BOOL cameraWasRecording = hasCameraRecordingResources();
+            BOOL audioWasRecording = g_usingStandaloneAudio;
             __block BOOL cameraStopResult = YES;
             __block BOOL audioStopResult = YES;
 
@@ -983,14 +1001,43 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     }
     
     MRLog(@"⚠️ No active recording found to stop");
-    if (isCameraRecording()) {
+    if (hasCameraRecordingResources()) {
         stopCameraRecording();
     }
+    stopStandaloneAudioRecording();
+    g_usingStandaloneAudio = false;
     g_isRecording = false;
     MRSyncSetStopLimitSeconds(-1.0);
     return Napi::Boolean::New(env, true);
 }
 
+Napi::Value PauseRecording(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    bool recording = g_isRecording || hasAVFoundationRecordingResources();
+    if (@available(macOS 12.3, *)) {
+        recording = recording || [ScreenCaptureKitRecorder isRecording];
+    }
+    if (!recording) {
+        Napi::Error::New(env, "No active recording to pause").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    MRSyncPause();
+    return Napi::Boolean::New(env, true);
+}
+
+Napi::Value ResumeRecording(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (!MRSyncIsPaused()) {
+        return Napi::Boolean::New(env, true);
+    }
+    MRSyncResume();
+    return Napi::Boolean::New(env, true);
+}
+
+Napi::Value GetRecordingPauseStatus(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), MRSyncIsPaused());
+}
+
 
 
 // NAPI Function: Get Windows List
@@ -1375,6 +1422,26 @@ Napi::Value PrewarmScreenCapture(const Napi::CallbackInfo& info) {
     return Napi::Boolean::New(env, false);
 }
 
+// Actual native state, independent of the legacy first-ten-frames/UI flag.
+Napi::Value GetRecordingLifecycleStatus(const Napi::CallbackInfo& info) {
+    bool recording = hasAVFoundationRecordingResources() || isIOSDeviceRecordingPending();
+    bool starting = false;
+    bool stopping = isCameraRecordingStopping() || isIOSDeviceRecordingStopping() || isAVFoundationRecordingStopping();
+    if (@available(macOS 12.3, *)) {
+        recording = recording || [ScreenCaptureKitRecorder isRecording];
+        starting = [ScreenCaptureKitRecorder isScheduling];
+        stopping = stopping || [ScreenCaptureKitRecorder isCleaningUp];
+    }
+    Napi::Object result = Napi::Object::New(info.Env());
+    result.Set("isRecording", recording);
+    result.Set("isStarting", starting);
+    result.Set("isStopping", stopping);
+    result.Set("isPaused", MRSyncIsPaused());
+    result.Set("pausedDuration", MRSyncGetPausedDurationSeconds());
+    result.Set("hasAuxiliaryRecording", hasCameraRecordingResources() || isStandaloneAudioRecording());
+    return result;
+}
+
 Napi::Value GetRecordingStatus(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
 
@@ -1755,8 +1822,12 @@ Napi::Value CheckPermissions(const Napi::CallbackInfo& info) {
 
 // Initialize NAPI Module
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    exports.Set("getRecordingLifecycleStatus", Napi::Function::New(env, GetRecordingLifecycleStatus));
     exports.Set(Napi::String::New(env, "startRecording"), Napi::Function::New(env, StartRecording));
     exports.Set(Napi::String::New(env, "stopRecording"), Napi::Function::New(env, StopRecording));
+    exports.Set(Napi::String::New(env, "pauseRecording"), Napi::Function::New(env, PauseRecording));
+    exports.Set(Napi::String::New(env, "resumeRecording"), Napi::Function::New(env, ResumeRecording));
+    exports.Set(Napi::String::New(env, "getRecordingPauseStatus"), Napi::Function::New(env, GetRecordingPauseStatus));
 
     exports.Set(Napi::String::New(env, "getAudioDevices"), Napi::Function::New(env, GetAudioDevices));
     exports.Set(Napi::String::New(env, "getCameraDevices"), Napi::Function::New(env, GetCameraDevices));

package/src/recording_writer_safety.h

@@ -0,0 +1,66 @@
+#pragma once
+#import <AVFoundation/AVFoundation.h>
+
+// Call only after detaching and draining sample callbacks. A writer which has
+// not received its first frame cannot be marked/finished: AVFoundation raises
+// NSInternalInconsistencyException, which a JavaScript catch cannot intercept.
+static BOOL MRFinishAssetWriterSafely(AVAssetWriter *writer,
+                                    NSTimeInterval timeoutSeconds,
+                                    double stopLimitSeconds = -1.0) {
+    if (!writer) return YES;
+    dispatch_semaphore_t finished = nil;
+    @try {
+        AVAssetWriterStatus status = writer.status;
+        if (status == AVAssetWriterStatusCompleted) return YES;
+        if (status == AVAssetWriterStatusUnknown) {
+            [writer cancelWriting];
+            return NO;
+        }
+        if (status != AVAssetWriterStatusWriting) return NO;
+        if (stopLimitSeconds > 0 && isfinite(stopLimitSeconds)) {
+            [writer endSessionAtSourceTime:CMTimeMakeWithSeconds(stopLimitSeconds, 600)];
+        }
+        // Respect each recorder's bounded wait. A global 60-second floor blocks
+        // the native stop path synchronously and makes the app appear frozen.
+        // Timing out is safe because the writer is deliberately not cancelled.
+        NSTimeInterval waitSeconds =
+            isfinite(timeoutSeconds) && timeoutSeconds > 0 ? timeoutSeconds : 5.0;
+        finished = dispatch_semaphore_create(0);
+        // finishWriting marks all inputs as finished. The completion captures
+        // only its semaphore, never mutable globals from a subsequent session.
+        [writer finishWritingWithCompletionHandler:^{ dispatch_semaphore_signal(finished); }];
+        long timedOut = dispatch_semaphore_wait(finished,
+            dispatch_time(DISPATCH_TIME_NOW, (int64_t)(waitSeconds * NSEC_PER_SEC)));
+        if (timedOut) {
+            // NEVER cancel here. cancelWriting deletes the output file, so a
+            // finalization that is merely slow would destroy the user's
+            // recording — the editor then opens with no video. Waiting stops,
+            // the writer keeps finalizing in the background and still produces
+            // the file; only the "completed" confirmation is lost.
+            NSLog(@"[Recorder] Writer still finalizing after %.3fs; leaving it to finish", waitSeconds);
+            return NO;
+        }
+        return writer.status == AVAssetWriterStatusCompleted;
+    } @catch (NSException *exception) {
+        NSLog(@"[Recorder] Writer finalization failed safely: %@", exception.reason);
+        @try {
+            if (writer.status == AVAssetWriterStatusUnknown) {
+                // No first frame arrived, so there is no output file to lose.
+                [writer cancelWriting];
+            } else if (writer.status == AVAssetWriterStatusWriting) {
+                // Frames were written: cancelling would delete them. Trigger
+                // finalization best effort instead and do not wait on it.
+                [writer finishWritingWithCompletionHandler:^{}];
+            }
+        } @catch (NSException *cancelError) {
+            NSLog(@"[Recorder] Writer cancellation failed: %@", cancelError.reason);
+        }
+        return NO;
+    } @finally {
+#if !__has_feature(objc_arc)
+        // The copied completion block owns a separate reference, including
+        // when it runs after a timeout. Balance this call's create reference.
+        if (finished) dispatch_release(finished);
+#endif
+    }
+}

package/src/screen_capture_kit.h

@@ -13,9 +13,9 @@ API_AVAILABLE(macos(12.3))
 + (void)prewarmShareableContent;
 
 // MULTI-SESSION API: New session-based recording
-+ (NSString *)startRecordingWithConfiguration:(NSDictionary *)config
++ (BOOL)startRecordingWithConfiguration:(NSDictionary *)config
                                      delegate:(id)delegate
-                                        error:(NSError **)error;  // Returns sessionId
+                                        error:(NSError **)error;
 + (BOOL)stopRecording:(NSString *)sessionId;  // Stop specific session
 + (BOOL)isRecording:(NSString *)sessionId;    // Check specific session
 + (BOOL)isFullyInitialized:(NSString *)sessionId;  // Check if session's first frames received
@@ -26,6 +26,8 @@ API_AVAILABLE(macos(12.3))
 // LEGACY API: For backward compatibility (uses implicit default session)
 + (void)stopRecording;  // Stops all sessions
 + (BOOL)isRecording;    // Returns YES if ANY session is recording
++ (BOOL)isScheduling;
++ (BOOL)isCleaningUp;
 + (BOOL)isFullyInitialized;  // Check if default session initialized
 + (NSTimeInterval)getVideoStartTimestamp;  // Get default session timestamp