node-mac-recorder 2.12.5 → 2.13.1

package/src/screen_capture_kit.mm

@@ -1,90 +1,75 @@
 #import "screen_capture_kit.h"
+#import <CoreImage/CoreImage.h>
 
-// Global state
 static SCStream *g_stream = nil;
 static id<SCStreamDelegate> g_streamDelegate = nil;
 static id<SCStreamOutput> g_streamOutput = nil;
 static BOOL g_isRecording = NO;
+
+// Electron-safe direct writing approach
 static AVAssetWriter *g_assetWriter = nil;
-static AVAssetWriterInput *g_videoWriterInput = nil;
-static AVAssetWriterInput *g_audioWriterInput = nil;
-static NSString *g_outputPath = nil;
-static BOOL g_sessionStarted = NO;
+static AVAssetWriterInput *g_assetWriterInput = nil;
 static AVAssetWriterInputPixelBufferAdaptor *g_pixelBufferAdaptor = nil;
+static NSString *g_outputPath = nil;
+static CMTime g_startTime;
+static CMTime g_currentTime;
+static BOOL g_writerStarted = NO;
 
-@interface ScreenCaptureKitRecorderDelegate : NSObject <SCStreamDelegate>
-@property (nonatomic, copy) void (^completionHandler)(NSURL *outputURL, NSError *error);
-@end
-
-@interface ScreenCaptureKitStreamOutput : NSObject <SCStreamOutput>
+@interface ElectronSafeDelegate : NSObject <SCStreamDelegate>
 @end
 
-@implementation ScreenCaptureKitRecorderDelegate
+@implementation ElectronSafeDelegate
 - (void)stream:(SCStream *)stream didStopWithError:(NSError *)error {
-    NSLog(@"ScreenCaptureKit recording stopped with error: %@", error);
+    NSLog(@"🛑 ScreenCaptureKit stream stopped in delegate");
+    g_isRecording = NO;
     
-    // Finalize video file
-    if (g_assetWriter && g_assetWriter.status == AVAssetWriterStatusWriting) {
-        [g_videoWriterInput markAsFinished];
-        if (g_audioWriterInput) {
-            [g_audioWriterInput markAsFinished];
-        }
-        [g_assetWriter finishWritingWithCompletionHandler:^{
-            NSLog(@"✅ ScreenCaptureKit video file finalized: %@", g_outputPath);
-        }];
+    if (error) {
+        NSLog(@"❌ Stream stopped with error: %@", error);
+    } else {
+        NSLog(@"✅ ScreenCaptureKit stream stopped successfully");
     }
+    
+    // Finalize video writer
+    [ScreenCaptureKitRecorder finalizeVideoWriter];
 }
 @end
 
-@implementation ScreenCaptureKitStreamOutput
+@interface ElectronSafeOutput : NSObject <SCStreamOutput>
+@end
+
+@implementation ElectronSafeOutput
 - (void)stream:(SCStream *)stream didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer ofType:(SCStreamOutputType)type {
-    if (!g_assetWriter) {
-        return;
-    }
-    
-    // Start session on first sample
-    if (!g_sessionStarted && g_assetWriter.status == AVAssetWriterStatusWriting) {
-        CMTime presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
-        [g_assetWriter startSessionAtSourceTime:presentationTime];
-        g_sessionStarted = YES;
-        NSLog(@"📽️ ScreenCaptureKit video session started at time: %lld/%d", presentationTime.value, presentationTime.timescale);
-    }
-    
-    if (g_assetWriter.status != AVAssetWriterStatusWriting) {
+    if (!g_isRecording || type != SCStreamOutputTypeScreen || !g_assetWriterInput) {
         return;
     }
     
-    switch (type) {
-        case SCStreamOutputTypeScreen:
-            if (g_pixelBufferAdaptor && g_pixelBufferAdaptor.assetWriterInput.isReadyForMoreMediaData) {
-                // Convert sample buffer to pixel buffer
-                CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
-                if (pixelBuffer) {
-                    CMTime presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
-                    BOOL success = [g_pixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:presentationTime];
-                    if (!success) {
-                        NSLog(@"❌ Failed to append pixel buffer: %@", g_assetWriter.error);
-                    }
-                }
-            }
-            break;
-        case SCStreamOutputTypeAudio:
-            if (g_audioWriterInput && g_audioWriterInput.isReadyForMoreMediaData) {
-                BOOL success = [g_audioWriterInput appendSampleBuffer:sampleBuffer];
-                if (!success) {
-                    NSLog(@"❌ Failed to append audio sample: %@", g_assetWriter.error);
-                }
-            }
-            break;
-        case SCStreamOutputTypeMicrophone:
-            // Handle microphone input (if needed in future)
-            if (g_audioWriterInput && g_audioWriterInput.isReadyForMoreMediaData) {
-                BOOL success = [g_audioWriterInput appendSampleBuffer:sampleBuffer];
-                if (!success) {
-                    NSLog(@"❌ Failed to append microphone sample: %@", g_assetWriter.error);
+    @autoreleasepool {
+        // Initialize video writer on first frame
+        if (!g_writerStarted && g_assetWriter && g_assetWriterInput) {
+            g_startTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+            g_currentTime = g_startTime;
+            
+            [g_assetWriter startWriting];
+            [g_assetWriter startSessionAtSourceTime:g_startTime];
+            g_writerStarted = YES;
+            NSLog(@"✅ Electron-safe video writer started");
+        }
+        
+        // Write sample buffer directly (Electron-safe approach)
+        if (g_writerStarted && g_assetWriterInput.isReadyForMoreMediaData) {
+            CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+            if (pixelBuffer && g_pixelBufferAdaptor) {
+                CMTime presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+                CMTime relativeTime = CMTimeSubtract(presentationTime, g_startTime);
+                
+                BOOL success = [g_pixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:relativeTime];
+                if (success) {
+                    g_currentTime = relativeTime;
+                } else {
+                    NSLog(@"⚠️ Failed to append pixel buffer");
                 }
             }
-            break;
+        }
     }
 }
 @end
@@ -92,358 +77,170 @@ static AVAssetWriterInputPixelBufferAdaptor *g_pixelBufferAdaptor = nil;
 @implementation ScreenCaptureKitRecorder
 
 + (BOOL)isScreenCaptureKitAvailable {
-    // ScreenCaptureKit'i tekrar etkinleştir - video writer ile
-    
     if (@available(macOS 12.3, *)) {
-        NSLog(@"🔍 ScreenCaptureKit availability check - macOS 12.3+ confirmed");
-        
-        // Try to access ScreenCaptureKit classes to verify they're actually available
-        @try {
-            Class scStreamClass = NSClassFromString(@"SCStream");
-            Class scContentFilterClass = NSClassFromString(@"SCContentFilter");
-            Class scShareableContentClass = NSClassFromString(@"SCShareableContent");
-            
-            if (scStreamClass && scContentFilterClass && scShareableContentClass) {
-                NSLog(@"✅ ScreenCaptureKit classes are available");
-                return YES;
-            } else {
-                NSLog(@"❌ ScreenCaptureKit classes not found");
-                NSLog(@"   SCStream: %@", scStreamClass ? @"✅" : @"❌");
-                NSLog(@"   SCContentFilter: %@", scContentFilterClass ? @"✅" : @"❌");
-                NSLog(@"   SCShareableContent: %@", scShareableContentClass ? @"✅" : @"❌");
-                return NO;
-            }
-        } @catch (NSException *exception) {
-            NSLog(@"❌ Exception checking ScreenCaptureKit classes: %@", exception.reason);
-            return NO;
-        }
+        return [SCShareableContent class] != nil && [SCStream class] != nil;
     }
-    NSLog(@"❌ macOS version < 12.3 - ScreenCaptureKit not available");
     return NO;
 }
 
-+ (BOOL)startRecordingWithConfiguration:(NSDictionary *)config 
-                               delegate:(id)delegate 
-                                  error:(NSError **)error {
++ (BOOL)startRecordingWithConfiguration:(NSDictionary *)config delegate:(id)delegate error:(NSError **)error {
+    if (g_isRecording) {
+        return NO;
+    }
     
-    if (@available(macOS 12.3, *)) {
-        @try {
-            // Get current app PID to exclude overlay windows
-            NSRunningApplication *currentApp = [NSRunningApplication currentApplication];
-            pid_t currentPID = currentApp.processIdentifier;
-            
-            // Get all shareable content synchronously for immediate response
-            dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
-            __block BOOL success = NO;
-            __block NSError *contentError = nil;
-            
-            [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *content, NSError *error) {
-                if (error) {
-                    NSLog(@"Failed to get shareable content: %@", error);
-                    contentError = error;
-                    dispatch_semaphore_signal(semaphore);
-                    return;
-                }
-                
-                // Find display to record
-                SCDisplay *targetDisplay = content.displays.firstObject; // Default to first display
-                if (config[@"displayId"]) {
-                    CGDirectDisplayID displayID = [config[@"displayId"] unsignedIntValue];
-                    for (SCDisplay *display in content.displays) {
-                        if (display.displayID == displayID) {
-                            targetDisplay = display;
-                            break;
-                        }
-                    }
-                }
-                
-                // Get current process and Electron app windows to exclude
-                NSMutableArray *excludedWindows = [NSMutableArray array];
-                NSMutableArray *excludedApps = [NSMutableArray array];
-                
-                // Exclude current Node.js process windows (overlay selectors)
-                for (SCWindow *window in content.windows) {
-                    if (window.owningApplication.processID == currentPID) {
-                        [excludedWindows addObject:window];
-                        NSLog(@"🚫 Excluding Node.js overlay window: %@ (PID: %d)", window.title, currentPID);
-                    }
-                }
-                
-                // Also try to exclude Electron app if running (common overlay use case)
-                for (SCWindow *window in content.windows) {
-                    NSString *appName = window.owningApplication.applicationName;
-                    NSString *windowTitle = window.title ? window.title : @"<No Title>";
-                    
-                    // Debug: Log all windows to see what we're dealing with (only for small subset)
-                    if ([appName containsString:@"Electron"] || [windowTitle containsString:@"camera"]) {
-                        NSLog(@"📋 Found potential exclude window: '%@' from app: '%@' (PID: %d, Level: %ld)", 
-                              windowTitle, appName, window.owningApplication.processID, (long)window.windowLayer);
-                    }
-                    
-                    // Comprehensive Electron window detection
-                    BOOL shouldExclude = NO;
-                    
-                    // Check app name patterns
-                    if ([appName containsString:@"Electron"] || 
-                        [appName isEqualToString:@"electron"] ||
-                        [appName isEqualToString:@"Electron Helper"]) {
-                        shouldExclude = YES;
-                    }
-                    
-                    // Check window title patterns
-                    if ([windowTitle containsString:@"Electron"] ||
-                        [windowTitle containsString:@"camera"] ||
-                        [windowTitle containsString:@"Camera"] ||
-                        [windowTitle containsString:@"overlay"] ||
-                        [windowTitle containsString:@"Overlay"]) {
-                        shouldExclude = YES;
-                    }
-                    
-                    // Check window properties (transparent, always on top windows)
-                    if (window.windowLayer > 100) { // High window levels (like alwaysOnTop)
-                        shouldExclude = YES;
-                        NSLog(@"📋 High-level window detected: '%@' (Level: %ld)", windowTitle, (long)window.windowLayer);
-                    }
-                    
-                    if (shouldExclude) {
-                        [excludedWindows addObject:window];
-                        NSLog(@"🚫 Excluding window: '%@' from %@ (PID: %d, Level: %ld)", 
-                              windowTitle, appName, window.owningApplication.processID, (long)window.windowLayer);
-                    }
-                }
-                
-                NSLog(@"📊 Total windows to exclude: %lu", (unsigned long)excludedWindows.count);
-                
-                // Create content filter - exclude overlay windows from recording
-                SCContentFilter *filter = [[SCContentFilter alloc] 
-                    initWithDisplay:targetDisplay 
-                    excludingWindows:excludedWindows];
-                NSLog(@"🎯 Using window-level exclusion for overlay prevention");
-                
-                // Create stream configuration
-                SCStreamConfiguration *streamConfig = [[SCStreamConfiguration alloc] init];
-                
-                // Handle capture area if specified
-                if (config[@"captureRect"]) {
-                    NSDictionary *rect = config[@"captureRect"];
-                    streamConfig.width = [rect[@"width"] integerValue];
-                    streamConfig.height = [rect[@"height"] integerValue];
-                    // Note: ScreenCaptureKit crop rect would need additional handling
-                } else {
-                    streamConfig.width = (NSInteger)targetDisplay.width;
-                    streamConfig.height = (NSInteger)targetDisplay.height;
-                }
-                
-                streamConfig.minimumFrameInterval = CMTimeMake(1, 60); // 60 FPS
-                streamConfig.queueDepth = 5;
-                streamConfig.showsCursor = [config[@"captureCursor"] boolValue];
-                streamConfig.capturesAudio = [config[@"includeSystemAudio"] boolValue];
-                
-                // Setup video writer
-                g_outputPath = config[@"outputPath"];
-                if (![self setupVideoWriterWithWidth:streamConfig.width 
-                                               height:streamConfig.height 
-                                         outputPath:g_outputPath 
-                                      includeAudio:[config[@"includeSystemAudio"] boolValue] || [config[@"includeMicrophone"] boolValue]]) {
-                    NSLog(@"❌ Failed to setup video writer");
-                    contentError = [NSError errorWithDomain:@"ScreenCaptureKitError" code:-3 userInfo:@{NSLocalizedDescriptionKey: @"Video writer setup failed"}];
-                    dispatch_semaphore_signal(semaphore);
-                    return;
-                }
-                
-                // Create delegate and output
-                g_streamDelegate = [[ScreenCaptureKitRecorderDelegate alloc] init];
-                g_streamOutput = [[ScreenCaptureKitStreamOutput alloc] init];
-                
-                // Create and start stream
-                g_stream = [[SCStream alloc] initWithFilter:filter 
-                                              configuration:streamConfig 
-                                                   delegate:g_streamDelegate];
-                
-                // Add stream output using correct API
-                NSError *outputError = nil;
-                BOOL outputAdded = [g_stream addStreamOutput:g_streamOutput 
-                                                        type:SCStreamOutputTypeScreen 
-                                              sampleHandlerQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)
-                                                           error:&outputError];
-                if (!outputAdded) {
-                    NSLog(@"❌ Failed to add screen output: %@", outputError);
-                }
-                
-                if ([config[@"includeSystemAudio"] boolValue]) {
-                    if (@available(macOS 13.0, *)) {
-                        BOOL audioOutputAdded = [g_stream addStreamOutput:g_streamOutput 
-                                                                     type:SCStreamOutputTypeAudio 
-                                                           sampleHandlerQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)
-                                                                        error:&outputError];
-                        if (!audioOutputAdded) {
-                            NSLog(@"❌ Failed to add audio output: %@", outputError);
-                        }
-                    }
-                }
-                
-                [g_stream startCaptureWithCompletionHandler:^(NSError *streamError) {
-                    if (streamError) {
-                        NSLog(@"❌ Failed to start ScreenCaptureKit recording: %@", streamError);
-                        contentError = streamError;
-                        g_isRecording = NO;
-                    } else {
-                        NSLog(@"✅ ScreenCaptureKit recording started successfully (excluding %lu overlay windows)", (unsigned long)excludedWindows.count);
-                        g_isRecording = YES;
-                        success = YES;
-                    }
-                    dispatch_semaphore_signal(semaphore);
-                }];
-            }];
-            
-            // Wait for completion (with timeout)
-            dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC);
-            if (dispatch_semaphore_wait(semaphore, timeout) == 0) {
-                if (contentError && error) {
-                    *error = contentError;
-                }
-                return success;
+    g_outputPath = config[@"outputPath"];
+    g_writerStarted = NO;
+    
+    // Setup Electron-safe video writer
+    [ScreenCaptureKitRecorder setupVideoWriter];
+    
+    NSLog(@"🎬 Starting Electron-safe ScreenCaptureKit recording");
+    
+    [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *content, NSError *contentError) {
+        if (contentError) {
+            NSLog(@"❌ Failed to get content: %@", contentError);
+            return;
+        }
+        
+        // Get primary display
+        SCDisplay *targetDisplay = content.displays.firstObject;
+        
+        // Simple content filter - no exclusions for now
+        SCContentFilter *filter = [[SCContentFilter alloc] initWithDisplay:targetDisplay excludingWindows:@[]];
+        
+        // Stream configuration
+        SCStreamConfiguration *streamConfig = [[SCStreamConfiguration alloc] init];
+        streamConfig.width = 1280;
+        streamConfig.height = 720;
+        streamConfig.minimumFrameInterval = CMTimeMake(1, 30);
+        streamConfig.pixelFormat = kCVPixelFormatType_32BGRA;
+        
+        // Create Electron-safe delegates
+        g_streamDelegate = [[ElectronSafeDelegate alloc] init];
+        g_streamOutput = [[ElectronSafeOutput alloc] init];
+        
+        // Create stream
+        g_stream = [[SCStream alloc] initWithFilter:filter configuration:streamConfig delegate:g_streamDelegate];
+        
+        [g_stream addStreamOutput:g_streamOutput
+                             type:SCStreamOutputTypeScreen
+               sampleHandlerQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)
+                            error:nil];
+        
+        [g_stream startCaptureWithCompletionHandler:^(NSError *startError) {
+            if (startError) {
+                NSLog(@"❌ Failed to start capture: %@", startError);
             } else {
-                NSLog(@"⏰ ScreenCaptureKit initialization timeout");
-                if (error) {
-                    *error = [NSError errorWithDomain:@"ScreenCaptureKitError" 
-                                                 code:-2 
-                                             userInfo:@{NSLocalizedDescriptionKey: @"Initialization timeout"}];
-                }
-                return NO;
+                NSLog(@"✅ Frame capture started");
+                g_isRecording = YES;
             }
-            
-        } @catch (NSException *exception) {
-            NSLog(@"ScreenCaptureKit recording exception: %@", exception);
-            if (error) {
-                *error = [NSError errorWithDomain:@"ScreenCaptureKitError" 
-                                             code:-1 
-                                         userInfo:@{NSLocalizedDescriptionKey: exception.reason}];
-            }
-            return NO;
-        }
-    }
+        }];
+    }];
     
-    return NO;
+    return YES;
 }
 
 + (void)stopRecording {
-    if (@available(macOS 12.3, *)) {
-        if (g_stream && g_isRecording) {
-            [g_stream stopCaptureWithCompletionHandler:^(NSError *error) {
-                if (error) {
-                    NSLog(@"Error stopping ScreenCaptureKit recording: %@", error);
-                } else {
-                    NSLog(@"ScreenCaptureKit recording stopped successfully");
-                }
-                
-                // Finalize video file
-                if (g_assetWriter && g_assetWriter.status == AVAssetWriterStatusWriting) {
-                    [g_videoWriterInput markAsFinished];
-                    if (g_audioWriterInput) {
-                        [g_audioWriterInput markAsFinished];
-                    }
-                    [g_assetWriter finishWritingWithCompletionHandler:^{
-                        NSLog(@"✅ ScreenCaptureKit video file finalized: %@", g_outputPath);
-                        
-                        // Cleanup
-                        g_assetWriter = nil;
-                        g_videoWriterInput = nil;
-                        g_audioWriterInput = nil;
-                        g_pixelBufferAdaptor = nil;
-                        g_outputPath = nil;
-                        g_sessionStarted = NO;
-                    }];
-                }
-                
-                g_isRecording = NO;
-                g_stream = nil;
-                g_streamDelegate = nil;
-                g_streamOutput = nil;
-            }];
-        }
+    if (!g_isRecording || !g_stream) {
+        return;
     }
+    
+    NSLog(@"🛑 Stopping Electron-safe ScreenCaptureKit recording");
+    
+    [g_stream stopCaptureWithCompletionHandler:^(NSError *stopError) {
+        if (stopError) {
+            NSLog(@"❌ Stop error: %@", stopError);
+        } else {
+            NSLog(@"✅ ScreenCaptureKit stream stopped in completion handler");
+        }
+        // Video finalization happens in delegate
+    }];
 }
 
 + (BOOL)isRecording {
     return g_isRecording;
 }
 
-+ (BOOL)setupVideoWriterWithWidth:(NSInteger)width 
-                           height:(NSInteger)height 
-                       outputPath:(NSString *)outputPath 
-                     includeAudio:(BOOL)includeAudio {
++ (void)setupVideoWriter {
+    if (g_assetWriter) {
+        return; // Already setup
+    }
+    
+    NSLog(@"🔧 Setting up Electron-safe video writer");
     
-    // Create asset writer with MP4 format for better compatibility
-    NSURL *outputURL = [NSURL fileURLWithPath:outputPath];
+    NSURL *outputURL = [NSURL fileURLWithPath:g_outputPath];
     NSError *error = nil;
-    g_assetWriter = [[AVAssetWriter alloc] initWithURL:outputURL fileType:AVFileTypeMPEG4 error:&error];
+    
+    g_assetWriter = [[AVAssetWriter alloc] initWithURL:outputURL fileType:AVFileTypeQuickTimeMovie error:&error];
     
     if (error || !g_assetWriter) {
         NSLog(@"❌ Failed to create asset writer: %@", error);
-        return NO;
+        return;
     }
     
-    // Video writer input - basic settings for maximum compatibility
+    // Electron-safe video settings
     NSDictionary *videoSettings = @{
         AVVideoCodecKey: AVVideoCodecTypeH264,
-        AVVideoWidthKey: @(width),
-        AVVideoHeightKey: @(height)
+        AVVideoWidthKey: @1280,
+        AVVideoHeightKey: @720,
+        AVVideoCompressionPropertiesKey: @{
+            AVVideoAverageBitRateKey: @(1280 * 720 * 2),
+            AVVideoMaxKeyFrameIntervalKey: @30
+        }
     };
     
-    g_videoWriterInput = [[AVAssetWriterInput alloc] initWithMediaType:AVMediaTypeVideo outputSettings:videoSettings];
-    g_videoWriterInput.expectsMediaDataInRealTime = YES;
+    g_assetWriterInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo outputSettings:videoSettings];
+    g_assetWriterInput.expectsMediaDataInRealTime = YES; // Important for live capture
     
-    if (![g_assetWriter canAddInput:g_videoWriterInput]) {
-        NSLog(@"❌ Cannot add video input to asset writer");
-        return NO;
-    }
-    [g_assetWriter addInput:g_videoWriterInput];
-    
-    // Create pixel buffer adaptor for ScreenCaptureKit compatibility
+    // Pixel buffer attributes matching ScreenCaptureKit format
     NSDictionary *pixelBufferAttributes = @{
-        (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA),
-        (NSString *)kCVPixelBufferWidthKey: @(width),
-        (NSString *)kCVPixelBufferHeightKey: @(height),
-        (NSString *)kCVPixelBufferIOSurfacePropertiesKey: @{}
+        (NSString*)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA),
+        (NSString*)kCVPixelBufferWidthKey: @1280,
+        (NSString*)kCVPixelBufferHeightKey: @720
     };
     
-    g_pixelBufferAdaptor = [[AVAssetWriterInputPixelBufferAdaptor alloc] 
-        initWithAssetWriterInput:g_videoWriterInput 
-        sourcePixelBufferAttributes:pixelBufferAttributes];
-    
-    if (!g_pixelBufferAdaptor) {
-        NSLog(@"❌ Cannot create pixel buffer adaptor");
-        return NO;
-    }
+    g_pixelBufferAdaptor = [AVAssetWriterInputPixelBufferAdaptor assetWriterInputPixelBufferAdaptorWithAssetWriterInput:g_assetWriterInput sourcePixelBufferAttributes:pixelBufferAttributes];
     
-    // Audio writer input (if needed)
-    if (includeAudio) {
-        NSDictionary *audioSettings = @{
-            AVFormatIDKey: @(kAudioFormatMPEG4AAC),
-            AVSampleRateKey: @(44100.0),
-            AVNumberOfChannelsKey: @(2),
-            AVEncoderBitRateKey: @(128000)
-        };
-        
-        g_audioWriterInput = [[AVAssetWriterInput alloc] initWithMediaType:AVMediaTypeAudio outputSettings:audioSettings];
-        g_audioWriterInput.expectsMediaDataInRealTime = YES;
-        
-        if ([g_assetWriter canAddInput:g_audioWriterInput]) {
-            [g_assetWriter addInput:g_audioWriterInput];
-        }
+    if ([g_assetWriter canAddInput:g_assetWriterInput]) {
+        [g_assetWriter addInput:g_assetWriterInput];
+        NSLog(@"✅ Electron-safe video writer setup complete");
+    } else {
+        NSLog(@"❌ Failed to add input to asset writer");
     }
+}
+
++ (void)finalizeVideoWriter {
+    NSLog(@"🎬 Finalizing Electron-safe video writer");
     
-    // Start writing (session will be started when first sample arrives)
-    if (![g_assetWriter startWriting]) {
-        NSLog(@"❌ Failed to start writing: %@", g_assetWriter.error);
-        return NO;
+    if (!g_assetWriter || !g_writerStarted) {
+        NSLog(@"⚠️ Video writer not started, cleaning up");
+        [ScreenCaptureKitRecorder cleanupVideoWriter];
+        return;
     }
     
-    g_sessionStarted = NO;  // Reset session flag
-    NSLog(@"✅ ScreenCaptureKit video writer setup complete: %@", outputPath);
+    [g_assetWriterInput markAsFinished];
     
-    return YES;
+    [g_assetWriter finishWritingWithCompletionHandler:^{
+        if (g_assetWriter.status == AVAssetWriterStatusCompleted) {
+            NSLog(@"✅ Electron-safe video created successfully: %@", g_outputPath);
+        } else {
+            NSLog(@"❌ Video creation failed: %@", g_assetWriter.error);
+        }
+        
+        [ScreenCaptureKitRecorder cleanupVideoWriter];
+    }];
+}
+
++ (void)cleanupVideoWriter {
+    g_assetWriter = nil;
+    g_assetWriterInput = nil;
+    g_pixelBufferAdaptor = nil;
+    g_writerStarted = NO;
+    g_stream = nil;
+    g_streamDelegate = nil;
+    g_streamOutput = nil;
+    
+    NSLog(@"🧹 Video writer cleanup complete");
 }
 
 @end