node-mac-recorder 2.24.7 → 2.24.9

package/binding.gyp

@@ -7,6 +7,7 @@
         "src/screen_capture_kit.mm",
         "src/avfoundation_recorder.mm",
         "src/camera_recorder.mm",
+        "src/ios_device_recorder.mm",
         "src/sync_timeline.mm",
         "src/audio_recorder.mm",
         "src/audio_mixer.mm",
@@ -42,7 +43,8 @@
           "-framework ApplicationServices",
           "-framework Carbon",
           "-framework Accessibility",
-          "-framework CoreAudio"
+          "-framework CoreAudio",
+          "-framework CoreMediaIO"
         ]
       },
       "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ]

package/index.js

@@ -153,6 +153,170 @@ class MacRecorder extends EventEmitter {
 		});
 	}
 
+	/**
+	 * USB uzerinden AVFoundation muxed capture kaynagi olarak gorunen
+	 * iPhone/iPad cihazlarini listeler. Continuity Camera cihazlari bu listeye
+	 * dahil edilmez; bu kaynak telefonun kamera sensoru degil ekran akışıdır.
+	 */
+	async getIOSCaptureDevices() {
+		if (typeof nativeBinding.getIOSCaptureDevices !== "function") return [];
+		const devices = nativeBinding.getIOSCaptureDevices();
+		if (!Array.isArray(devices)) return [];
+		return devices.map((device) => ({
+			id: device?.id || "",
+			name: device?.name || "iPhone",
+			manufacturer: device?.manufacturer || "Apple",
+			model: device?.model || null,
+			connected: device?.connected !== false,
+			suspended: device?.suspended === true,
+			width: Number(device?.width) || 0,
+			height: Number(device?.height) || 0,
+			hasAudio: device?.hasAudio !== false,
+			transport: device?.transport || "usb",
+		}));
+	}
+
+	/**
+	 * QuickTime benzeri dogrudan USB iPhone ekran kaydi. Muxed aygitin kendi
+	 * video ve sesini tek, uzun-kayitlara dayanikli MOV dosyasina yazar.
+	 */
+	async startIOSRecording(outputPath, options = {}) {
+		if (this.isRecording) throw new Error("Recording is already in progress");
+		if (!outputPath) throw new Error("Output path is required");
+		if (typeof nativeBinding.startIOSDeviceRecording !== "function") {
+			throw new Error("This recorder build does not support USB iPhone capture");
+		}
+
+		const outputDir = path.dirname(outputPath);
+		if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+		this.outputPath = outputPath;
+		const sessionTimestamp = options.sessionTimestamp || Date.now();
+		const cameraOutputPath = options.captureCamera === true
+			? path.join(outputDir, `temp_camera_${sessionTimestamp}.mov`)
+			: null;
+		const audioOutputPath = options.includeMicrophone === true
+			? path.join(outputDir, `temp_audio_${sessionTimestamp}.mov`)
+			: null;
+		this.options = {
+			...this.options,
+			...options,
+			sourceType: "iphone",
+			captureCursor: false,
+			// The muxed USB source already contains the iPhone's own system audio.
+			// includeSystemAudio refers to the Mac and must never be added here.
+			includeSystemAudio: false,
+		};
+		this.cameraCaptureFile = cameraOutputPath;
+		this.audioCaptureFile = audioOutputPath;
+		this.cameraCaptureActive = options.captureCamera === true;
+		this.audioCaptureActive = options.includeMicrophone === true;
+		this.sessionTimestamp = sessionTimestamp;
+		this.recordingMode = "iphone";
+
+		try {
+			const success = nativeBinding.startIOSDeviceRecording(
+				outputPath,
+				options.deviceId || options.iosDeviceId || "",
+				{
+					captureCamera: options.captureCamera === true,
+					cameraOutputPath,
+					cameraDeviceId: options.cameraDeviceId || "",
+					includeMicrophone: options.includeMicrophone === true,
+					audioOutputPath,
+					audioDeviceId: options.audioDeviceId || "",
+				},
+			);
+			if (!success) throw new Error("The iPhone capture session could not be started");
+
+			this.isRecording = true;
+			this.recordingStartTime = Date.now();
+			this.timelineStartTimestamp = this.recordingStartTime;
+			this.syncTimestamp = this.recordingStartTime;
+			this.recordingTimer = setInterval(() => {
+				this.emit(
+					"timeUpdate",
+					Math.floor((Date.now() - this.recordingStartTime) / 1000),
+				);
+			}, 1000);
+
+			const event = {
+				outputPath,
+				timestamp: this.recordingStartTime,
+				options: this.options,
+				nativeConfirmed: true,
+				cursorOutputPath: null,
+				keyboardOutputPath: null,
+				audioOutputPath,
+				cameraOutputPath,
+				sessionTimestamp: this.sessionTimestamp,
+				syncTimestamp: this.syncTimestamp,
+				fileTimestamp: this.sessionTimestamp,
+				sourceType: "iphone",
+			};
+			this.emit("recordingStarted", event);
+			this.emit("started", outputPath);
+			return outputPath;
+		} catch (error) {
+			this.recordingMode = null;
+			this.isRecording = false;
+			this.cameraCaptureActive = false;
+			this.audioCaptureActive = false;
+			this.cameraCaptureFile = null;
+			this.audioCaptureFile = null;
+			throw error;
+		}
+	}
+
+	async stopIOSRecording() {
+		if (this.recordingMode !== "iphone" || !this.isRecording) {
+			throw new Error("No iPhone recording in progress");
+		}
+		let success = false;
+		try {
+			success = nativeBinding.stopIOSDeviceRecording();
+		} finally {
+			if (this.recordingTimer) clearInterval(this.recordingTimer);
+			this.recordingTimer = null;
+			this.isRecording = false;
+			this.recordingMode = null;
+		}
+
+		const result = {
+			code: success ? 0 : 1,
+			outputPath: this.outputPath,
+			cameraOutputPath: this.cameraCaptureFile || null,
+			audioOutputPath: this.audioCaptureFile || null,
+			sessionTimestamp: this.sessionTimestamp,
+			syncTimestamp: this.syncTimestamp,
+			sourceType: "iphone",
+		};
+		if (this.cameraCaptureActive) {
+			this.emit("cameraCaptureStopped", {
+				outputPath: this.cameraCaptureFile,
+				success,
+				sessionTimestamp: this.sessionTimestamp,
+				syncTimestamp: this.syncTimestamp,
+			});
+		}
+		if (this.audioCaptureActive) {
+			this.emit("audioCaptureStopped", {
+				outputPath: this.audioCaptureFile,
+				success,
+				sessionTimestamp: this.sessionTimestamp,
+				syncTimestamp: this.syncTimestamp,
+			});
+		}
+		this.cameraCaptureActive = false;
+		this.audioCaptureActive = false;
+		this.emit("stopped", result);
+		if (success && fs.existsSync(this.outputPath)) {
+			this.emit("completed", this.outputPath);
+		}
+		this.sessionTimestamp = null;
+		this.syncTimestamp = null;
+		return result;
+	}
+
 	/**
 	 * macOS ekranlarını listeler
 	 */
@@ -1227,6 +1391,9 @@ class MacRecorder extends EventEmitter {
 		if (!this.isRecording) {
 			throw new Error("No recording in progress");
 		}
+		if (this.recordingMode === "iphone") {
+			return this.stopIOSRecording();
+		}
 
 		return new Promise(async (resolve, reject) => {
 			const stopRequestedAt = Date.now();
@@ -1399,7 +1566,11 @@ class MacRecorder extends EventEmitter {
 	 * Kayıt durumunu döndürür
 	 */
 	getStatus() {
-		const nativeStatus = nativeBinding.getRecordingStatus();
+		const nativeStatus =
+			this.recordingMode === "iphone" &&
+			typeof nativeBinding.getIOSDeviceRecordingStatus === "function"
+				? nativeBinding.getIOSDeviceRecordingStatus().isRecording === true
+				: nativeBinding.getRecordingStatus();
 		return {
 			isRecording: this.isRecording && nativeStatus,
 			outputPath: this.outputPath,

package/package.json

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

package/src/audio_recorder.mm

@@ -337,6 +337,12 @@ static NSString *g_lastStandaloneAudioOutputPath = nil;
     
     CMTime timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
 
+    // Keep microphone warm-up outside the recording until the USB iPhone movie
+    // output has actually started writing its first frame.
+    if (MRSyncShouldHoldForPrimary(timestamp)) {
+        return;
+    }
+
     // A/V SYNC: Hold audio samples until camera produces first frame
     // This ensures both audio and camera files start from the same wall-clock moment
     if (MRSyncShouldHoldAudioSample(timestamp)) {

package/src/camera_recorder.mm

@@ -526,6 +526,12 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
 
     CMTime timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
 
+    // Drop camera warm-up frames until the primary source (USB iPhone screen)
+    // has committed its first frame. This keeps all files on one t=0 boundary.
+    if (MRSyncShouldHoldForPrimary(timestamp)) {
+        return;
+    }
+
     // A/V SYNC: Signal camera's first frame to release audio hold
     MRSyncMarkCameraFirstFrame(timestamp);
 

package/src/cursor_tracker.mm

@@ -865,9 +865,30 @@ static bool g_leftMouseDown = false;
 static bool g_rightMouseDown = false;
 static NSString *g_lastEventType = @"move";
 
+// Erisilebilirlik izni durumu (istem GOSTERMEDEN).
+// NEDEN: izin yokken bile AX cagrilari yapiliyordu; macOS bunun uzerine
+// "Erisilebilirlik" izin dialogunu aciyor ve bu fonksiyon kayit boyunca
+// yuksek frekansta cagrildigi icin istem tekrar tekrar cikiyor. Durum
+// saniyede bir tazelenir: kullanici izni verdigi anda yol kendiliginden
+// devreye girer.
+static bool accessibilityTrustedCached(void) {
+    static CFAbsoluteTime lastCheck = 0;
+    static bool trusted = false;
+    CFAbsoluteTime now = CFAbsoluteTimeGetCurrent();
+    if (lastCheck == 0 || now - lastCheck > 1.0) {
+        trusted = AXIsProcessTrusted();
+        lastCheck = now;
+    }
+    return trusted;
+}
+
 // Accessibility tabanlı cursor tip tespiti
 static NSString* detectCursorTypeUsingAccessibility(CGPoint cursorPos) {
     @autoreleasepool {
+        if (!accessibilityTrustedCached()) {
+            return nil;
+        }
+
         AXUIElementRef systemWide = AXUIElementCreateSystemWide();
         if (!systemWide) {
             return nil;

package/src/ios_device_recorder.mm

@@ -0,0 +1,534 @@
+#import <napi.h>
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMediaIO/CMIOHardware.h>
+#import <Foundation/Foundation.h>
+#import "logging.h"
+#import "sync_timeline.h"
+
+extern "C" bool startCameraRecording(NSString *outputPath, NSString *deviceId, NSError **error);
+extern "C" bool waitForCameraRecordingStart(double timeoutSeconds);
+extern "C" bool stopCameraRecording(void);
+extern "C" bool isCameraRecording(void);
+extern "C" bool startStandaloneAudioRecording(NSString *outputPath, NSString *preferredDeviceId, NSError **error);
+extern "C" bool stopStandaloneAudioRecording(void);
+extern "C" bool isStandaloneAudioRecording(void);
+
+@interface MRIOSDeviceRecorder : NSObject <AVCaptureFileOutputRecordingDelegate>
+@property(nonatomic, strong) AVCaptureSession *session;
+@property(nonatomic, strong) AVCaptureDeviceInput *deviceInput;
+@property(nonatomic, strong) AVCaptureMovieFileOutput *movieOutput;
+@property(nonatomic, copy) NSString *outputPath;
+@property(atomic) BOOL recording;
+@property(atomic) BOOL startCompleted;
+@property(atomic) BOOL finishCompleted;
+@property(atomic, strong) NSError *finishError;
+@property(nonatomic) BOOL captureCamera;
+@property(nonatomic) BOOL captureMicrophone;
+@property(nonatomic, copy) NSString *cameraOutputPath;
+@property(nonatomic, copy) NSString *audioOutputPath;
+@property(nonatomic, strong) NSDate *primaryStartedAt;
+@end
+
+@implementation MRIOSDeviceRecorder
+
+- (void)captureOutput:(AVCaptureFileOutput *)captureOutput
+        didStartRecordingToOutputFileAtURL:(NSURL *)fileURL
+        fromConnections:(NSArray<AVCaptureConnection *> *)connections {
+    self.recording = YES;
+    self.startCompleted = YES;
+    self.primaryStartedAt = [NSDate date];
+    MRSyncMarkPrimaryStarted(CMClockGetTime(CMClockGetHostTimeClock()));
+    MRLog(@"📱 iPhone capture started: %@", fileURL.path);
+}
+
+- (void)captureOutput:(AVCaptureFileOutput *)captureOutput
+        didFinishRecordingToOutputFileAtURL:(NSURL *)outputFileURL
+        fromConnections:(NSArray<AVCaptureConnection *> *)connections
+        error:(NSError *)error {
+    self.recording = NO;
+    self.finishError = error;
+    self.finishCompleted = YES;
+    if (error) {
+        NSNumber *successfullyFinished = error.userInfo[AVErrorRecordingSuccessfullyFinishedKey];
+        if (![successfullyFinished boolValue]) {
+            MRLog(@"❌ iPhone capture finalize failed: %@", error.localizedDescription);
+            return;
+        }
+    }
+    MRLog(@"✅ iPhone capture finalized: %@", outputFileURL.path);
+}
+
+@end
+
+static MRIOSDeviceRecorder *g_iosRecorder = nil;
+
+static void MREnableIOSScreenCaptureDevices(void) {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        CMIOObjectPropertyAddress address = {
+            kCMIOHardwarePropertyAllowScreenCaptureDevices,
+            kCMIOObjectPropertyScopeGlobal,
+            kCMIOObjectPropertyElementMain
+        };
+        UInt32 allow = 1;
+        OSStatus status = CMIOObjectSetPropertyData(
+            kCMIOObjectSystemObject,
+            &address,
+            0,
+            NULL,
+            sizeof(allow),
+            &allow
+        );
+        if (status == noErr) {
+            MRLog(@"✅ CoreMediaIO iPhone screen capture devices enabled");
+        } else {
+            MRLog(@"❌ CoreMediaIO could not enable iPhone screen capture devices (OSStatus=%d)", (int)status);
+        }
+    });
+}
+
+static NSArray<AVCaptureDevice *> *MRDiscoverIOSCaptureDevices(void) {
+    NSMutableArray<AVCaptureDevice *> *result = [NSMutableArray array];
+    NSMutableSet<NSString *> *seenIds = [NSMutableSet set];
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    for (AVCaptureDevice *device in [AVCaptureDevice devicesWithMediaType:AVMediaTypeMuxed]) {
+        if (device.uniqueID.length == 0 || [seenIds containsObject:device.uniqueID]) continue;
+        [seenIds addObject:device.uniqueID];
+        [result addObject:device];
+    }
+#pragma clang diagnostic pop
+
+    NSMutableArray<AVCaptureDeviceType> *deviceTypes = [NSMutableArray array];
+    if (@available(macOS 10.15, *)) {
+        [deviceTypes addObject:AVCaptureDeviceTypeExternalUnknown];
+    }
+    if (@available(macOS 14.0, *)) {
+        [deviceTypes addObject:AVCaptureDeviceTypeExternal];
+    }
+    if (deviceTypes.count > 0) {
+        AVCaptureDeviceDiscoverySession *discovery =
+            [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:deviceTypes
+                                                                   mediaType:AVMediaTypeMuxed
+                                                                    position:AVCaptureDevicePositionUnspecified];
+        for (AVCaptureDevice *device in discovery.devices) {
+            if (device.uniqueID.length == 0 || [seenIds containsObject:device.uniqueID]) continue;
+            [seenIds addObject:device.uniqueID];
+            [result addObject:device];
+        }
+    }
+    return result;
+}
+
+static NSArray<AVCaptureDevice *> *MRIOSCaptureDevices(void) {
+    MREnableIOSScreenCaptureDevices();
+
+    // CoreMediaIO publishes the USB screen device asynchronously after the
+    // allow flag changes. Poll briefly so the first click works without asking
+    // the user to close and reopen the recorder.
+    NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:3.0];
+    NSArray<AVCaptureDevice *> *devices = nil;
+    do {
+        devices = MRDiscoverIOSCaptureDevices();
+        if (devices.count > 0) break;
+        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
+                                 beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.05]];
+    } while ([deadline timeIntervalSinceNow] > 0);
+    return devices ?: @[];
+}
+
+static AVCaptureDevice *MRIOSDeviceForId(NSString *deviceId) {
+    NSArray<AVCaptureDevice *> *devices = MRIOSCaptureDevices();
+    if (deviceId.length == 0) return devices.firstObject;
+    for (AVCaptureDevice *device in devices) {
+        if ([device.uniqueID isEqualToString:deviceId]) return device;
+    }
+    return nil;
+}
+
+static bool MRWaitForFlag(bool (^readFlag)(void), NSTimeInterval timeoutSeconds) {
+    NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:timeoutSeconds];
+    while (!readFlag() && [deadline timeIntervalSinceNow] > 0) {
+        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
+                                 beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.01]];
+    }
+    return readFlag();
+}
+
+extern "C" NSArray<NSDictionary *> *listIOSCaptureDevices(void) {
+    NSMutableArray<NSDictionary *> *devices = [NSMutableArray array];
+    for (AVCaptureDevice *device in MRIOSCaptureDevices()) {
+        CMVideoDimensions largest = {0, 0};
+        for (AVCaptureDeviceFormat *format in device.formats) {
+            CMVideoDimensions dimensions = CMVideoFormatDescriptionGetDimensions(format.formatDescription);
+            if ((int64_t)dimensions.width * dimensions.height >
+                (int64_t)largest.width * largest.height) {
+                largest = dimensions;
+            }
+        }
+        [devices addObject:@{
+            @"id": device.uniqueID ?: @"",
+            @"name": device.localizedName ?: @"iPhone",
+            @"manufacturer": device.manufacturer ?: @"Apple",
+            @"model": device.modelID ?: @"",
+            @"connected": @(device.isConnected),
+            @"suspended": @(device.isSuspended),
+            @"width": @(largest.width),
+            @"height": @(largest.height),
+            @"hasAudio": @YES,
+            @"transport": @"usb"
+        }];
+    }
+    return devices;
+}
+
+extern "C" bool startIOSDeviceRecording(NSString *outputPath,
+                                         NSString *deviceId,
+                                         BOOL captureCamera,
+                                         NSString *cameraOutputPath,
+                                         NSString *cameraDeviceId,
+                                         BOOL captureMicrophone,
+                                         NSString *audioOutputPath,
+                                         NSString *audioDeviceId,
+                                         NSError **errorOut) {
+    @autoreleasepool {
+        if (g_iosRecorder && (g_iosRecorder.recording || g_iosRecorder.startCompleted)) {
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:1
+                                            userInfo:@{NSLocalizedDescriptionKey: @"An iPhone recording is already active"}];
+            }
+            return false;
+        }
+
+        AVCaptureDevice *device = MRIOSDeviceForId(deviceId);
+        if (!device) {
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:2
+                                            userInfo:@{NSLocalizedDescriptionKey: @"No trusted USB iPhone capture device was found"}];
+            }
+            return false;
+        }
+
+        NSError *directoryError = nil;
+        NSString *directory = [outputPath stringByDeletingLastPathComponent];
+        [[NSFileManager defaultManager] createDirectoryAtPath:directory
+                                  withIntermediateDirectories:YES
+                                                   attributes:nil
+                                                        error:&directoryError];
+        if (directoryError) {
+            if (errorOut) *errorOut = directoryError;
+            return false;
+        }
+        [[NSFileManager defaultManager] removeItemAtPath:outputPath error:nil];
+        if (captureCamera && cameraOutputPath.length > 0) {
+            [[NSFileManager defaultManager] removeItemAtPath:cameraOutputPath error:nil];
+        }
+        if (captureMicrophone && audioOutputPath.length > 0) {
+            [[NSFileManager defaultManager] removeItemAtPath:audioOutputPath error:nil];
+        }
+
+        NSError *inputError = nil;
+        AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:device
+                                                                            error:&inputError];
+        if (!input) {
+            if (errorOut) *errorOut = inputError;
+            return false;
+        }
+
+        MRIOSDeviceRecorder *recorder = [[MRIOSDeviceRecorder alloc] init];
+        recorder.session = [[AVCaptureSession alloc] init];
+        recorder.deviceInput = input;
+        recorder.movieOutput = [[AVCaptureMovieFileOutput alloc] init];
+        recorder.outputPath = outputPath;
+        recorder.recording = NO;
+        recorder.startCompleted = NO;
+        recorder.finishCompleted = NO;
+        recorder.finishError = nil;
+        recorder.captureCamera = captureCamera;
+        recorder.captureMicrophone = captureMicrophone;
+        recorder.cameraOutputPath = cameraOutputPath;
+        recorder.audioOutputPath = audioOutputPath;
+        recorder.primaryStartedAt = nil;
+
+        [recorder.session beginConfiguration];
+        if ([recorder.session canSetSessionPreset:AVCaptureSessionPresetHigh]) {
+            recorder.session.sessionPreset = AVCaptureSessionPresetHigh;
+        }
+        if (![recorder.session canAddInput:input]) {
+            [recorder.session commitConfiguration];
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:3
+                                            userInfo:@{NSLocalizedDescriptionKey: @"The iPhone capture input could not be attached"}];
+            }
+            return false;
+        }
+        [recorder.session addInput:input];
+        if (![recorder.session canAddOutput:recorder.movieOutput]) {
+            [recorder.session commitConfiguration];
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:4
+                                            userInfo:@{NSLocalizedDescriptionKey: @"The iPhone movie output could not be attached"}];
+            }
+            return false;
+        }
+        [recorder.session addOutput:recorder.movieOutput];
+        [recorder.session commitConfiguration];
+
+        // Frequent movie fragments keep long recordings recoverable if the cable
+        // disconnects or the app exits before the final movie atom is written.
+        recorder.movieOutput.movieFragmentInterval = CMTimeMakeWithSeconds(2.0, 600);
+        g_iosRecorder = recorder;
+
+        // Camera and microphone sessions are prepared first but discard their
+        // warm-up samples until AVCaptureMovieFileOutput confirms the iPhone's
+        // first frame. Every produced file therefore starts at the same t=0.
+        MRSyncConfigure(captureMicrophone);
+        MRSyncConfigureCamera(captureCamera);
+        MRSyncConfigurePrimaryStart(captureCamera || captureMicrophone);
+
+        if (captureCamera) {
+            NSError *cameraError = nil;
+            if (cameraOutputPath.length == 0 ||
+                !startCameraRecording(cameraOutputPath, cameraDeviceId, &cameraError)) {
+                MRSyncConfigurePrimaryStart(NO);
+                MRSyncConfigure(NO);
+                g_iosRecorder = nil;
+                if (errorOut) {
+                    *errorOut = cameraError ?: [NSError errorWithDomain:@"MacRecorderIOS"
+                                                                    code:7
+                                                                userInfo:@{NSLocalizedDescriptionKey: @"The selected camera could not be started"}];
+                }
+                return false;
+            }
+        }
+
+        if (captureMicrophone) {
+            NSError *audioError = nil;
+            if (audioOutputPath.length == 0 ||
+                !startStandaloneAudioRecording(audioOutputPath, audioDeviceId, &audioError)) {
+                if (isCameraRecording()) stopCameraRecording();
+                MRSyncConfigurePrimaryStart(NO);
+                MRSyncConfigure(NO);
+                g_iosRecorder = nil;
+                if (errorOut) {
+                    *errorOut = audioError ?: [NSError errorWithDomain:@"MacRecorderIOS"
+                                                                  code:8
+                                                              userInfo:@{NSLocalizedDescriptionKey: @"The selected microphone could not be started"}];
+                }
+                return false;
+            }
+        }
+
+        [recorder.session startRunning];
+        if (!recorder.session.isRunning) {
+            if (isCameraRecording()) stopCameraRecording();
+            if (isStandaloneAudioRecording()) stopStandaloneAudioRecording();
+            MRSyncConfigurePrimaryStart(NO);
+            MRSyncConfigure(NO);
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:5
+                                            userInfo:@{NSLocalizedDescriptionKey: @"The iPhone capture session did not start"}];
+            }
+            g_iosRecorder = nil;
+            return false;
+        }
+
+        [recorder.movieOutput startRecordingToOutputFileURL:[NSURL fileURLWithPath:outputPath]
+                                          recordingDelegate:recorder];
+        bool started = MRWaitForFlag(^bool{
+            return recorder.startCompleted;
+        }, 10.0);
+        if (!started) {
+            if (recorder.movieOutput.isRecording) [recorder.movieOutput stopRecording];
+            [recorder.session stopRunning];
+            if (isCameraRecording()) stopCameraRecording();
+            if (isStandaloneAudioRecording()) stopStandaloneAudioRecording();
+            MRSyncConfigurePrimaryStart(NO);
+            MRSyncConfigure(NO);
+            g_iosRecorder = nil;
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:6
+                                            userInfo:@{NSLocalizedDescriptionKey: @"Timed out waiting for the first iPhone frame"}];
+            }
+            return false;
+        }
+        if (captureCamera && !waitForCameraRecordingStart(8.0)) {
+            MRLog(@"❌ Camera did not produce a synchronized frame for iPhone recording");
+            if (recorder.movieOutput.isRecording) [recorder.movieOutput stopRecording];
+            MRWaitForFlag(^bool{ return recorder.finishCompleted; }, 10.0);
+            [recorder.session stopRunning];
+            if (isCameraRecording()) stopCameraRecording();
+            if (isStandaloneAudioRecording()) stopStandaloneAudioRecording();
+            MRSyncConfigurePrimaryStart(NO);
+            MRSyncConfigure(NO);
+            g_iosRecorder = nil;
+            if (errorOut) {
+                *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
+                                                code:9
+                                            userInfo:@{NSLocalizedDescriptionKey: @"Timed out waiting for the selected camera"}];
+            }
+            return false;
+        }
+        return true;
+    }
+}
+
+extern "C" bool stopIOSDeviceRecording(void) {
+    @autoreleasepool {
+        MRIOSDeviceRecorder *recorder = g_iosRecorder;
+        if (!recorder) return true;
+
+        if (recorder.primaryStartedAt) {
+            NSTimeInterval duration = MAX(0.0, -[recorder.primaryStartedAt timeIntervalSinceNow]);
+            MRSyncSetStopLimitSeconds(duration);
+        }
+
+        BOOL cameraStopped = YES;
+        BOOL microphoneStopped = YES;
+        if (recorder.captureCamera && isCameraRecording()) {
+            cameraStopped = stopCameraRecording();
+        }
+        if (recorder.captureMicrophone && isStandaloneAudioRecording()) {
+            microphoneStopped = stopStandaloneAudioRecording();
+        }
+
+        if (recorder.movieOutput.isRecording) {
+            [recorder.movieOutput stopRecording];
+            MRWaitForFlag(^bool{
+                return recorder.finishCompleted;
+            }, 20.0);
+        }
+        if (recorder.session.isRunning) [recorder.session stopRunning];
+
+        NSError *finishError = recorder.finishError;
+        BOOL finished = recorder.finishCompleted || !recorder.startCompleted;
+        BOOL fileExists = [[NSFileManager defaultManager] fileExistsAtPath:recorder.outputPath];
+        MRSyncConfigurePrimaryStart(NO);
+        MRSyncConfigure(NO);
+        g_iosRecorder = nil;
+
+        if (finishError) {
+            NSNumber *successfullyFinished = finishError.userInfo[AVErrorRecordingSuccessfullyFinishedKey];
+            if (![successfullyFinished boolValue]) return false;
+        }
+        if (!cameraStopped || !microphoneStopped) {
+            MRLog(@"⚠️ iPhone recording finalized, but an auxiliary camera/microphone writer reported a stop error");
+        }
+        // Never discard a valid phone screen recording because an optional
+        // auxiliary source failed to finalize. The JS layer validates each
+        // returned path independently before packaging it.
+        return finished && fileExists;
+    }
+}
+
+extern "C" bool isIOSDeviceRecording(void) {
+    return g_iosRecorder && (g_iosRecorder.recording || g_iosRecorder.movieOutput.isRecording);
+}
+
+extern "C" NSString *currentIOSDeviceRecordingPath(void) {
+    return g_iosRecorder.outputPath;
+}
+
+Napi::Value GetIOSCaptureDevices(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    NSArray<NSDictionary *> *devices = listIOSCaptureDevices();
+    Napi::Array result = Napi::Array::New(env, devices.count);
+    for (NSUInteger index = 0; index < devices.count; index++) {
+        NSDictionary *device = devices[index];
+        Napi::Object item = Napi::Object::New(env);
+        item.Set("id", Napi::String::New(env, [device[@"id"] UTF8String]));
+        item.Set("name", Napi::String::New(env, [device[@"name"] UTF8String]));
+        item.Set("manufacturer", Napi::String::New(env, [device[@"manufacturer"] UTF8String]));
+        item.Set("model", Napi::String::New(env, [device[@"model"] UTF8String]));
+        item.Set("connected", Napi::Boolean::New(env, [device[@"connected"] boolValue]));
+        item.Set("suspended", Napi::Boolean::New(env, [device[@"suspended"] boolValue]));
+        item.Set("width", Napi::Number::New(env, [device[@"width"] intValue]));
+        item.Set("height", Napi::Number::New(env, [device[@"height"] intValue]));
+        item.Set("hasAudio", Napi::Boolean::New(env, true));
+        item.Set("transport", Napi::String::New(env, "usb"));
+        result.Set(index, item);
+    }
+    return result;
+}
+
+Napi::Value StartIOSDeviceRecording(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsString()) {
+        Napi::TypeError::New(env, "Output path is required").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    NSString *outputPath = [NSString stringWithUTF8String:info[0].As<Napi::String>().Utf8Value().c_str()];
+    NSString *deviceId = nil;
+    if (info.Length() > 1 && info[1].IsString()) {
+        deviceId = [NSString stringWithUTF8String:info[1].As<Napi::String>().Utf8Value().c_str()];
+    }
+    BOOL captureCamera = NO;
+    BOOL captureMicrophone = NO;
+    NSString *cameraOutputPath = nil;
+    NSString *cameraDeviceId = nil;
+    NSString *audioOutputPath = nil;
+    NSString *audioDeviceId = nil;
+    if (info.Length() > 2 && info[2].IsObject()) {
+        Napi::Object options = info[2].As<Napi::Object>();
+        auto readBool = [&](const char *key) -> BOOL {
+            Napi::Value value = options.Get(key);
+            return value.IsBoolean() && value.As<Napi::Boolean>().Value();
+        };
+        auto readString = [&](const char *key) -> NSString * {
+            Napi::Value value = options.Get(key);
+            if (!value.IsString()) return nil;
+            std::string text = value.As<Napi::String>().Utf8Value();
+            return text.empty() ? nil : [NSString stringWithUTF8String:text.c_str()];
+        };
+        captureCamera = readBool("captureCamera");
+        captureMicrophone = readBool("includeMicrophone");
+        cameraOutputPath = readString("cameraOutputPath");
+        cameraDeviceId = readString("cameraDeviceId");
+        audioOutputPath = readString("audioOutputPath");
+        audioDeviceId = readString("audioDeviceId");
+    }
+    NSError *error = nil;
+    bool success = startIOSDeviceRecording(outputPath,
+                                           deviceId,
+                                           captureCamera,
+                                           cameraOutputPath,
+                                           cameraDeviceId,
+                                           captureMicrophone,
+                                           audioOutputPath,
+                                           audioDeviceId,
+                                           &error);
+    if (!success && error) {
+        // startIOSDeviceRecording owns an inner autorelease pool. Do not bridge
+        // the NSError past that pool into V8; the JS wrapper turns false into a
+        // stable user-facing error and avoids a dangling Objective-C object.
+        MRLog(@"❌ iPhone capture could not start");
+    }
+    return Napi::Boolean::New(env, success);
+}
+
+Napi::Value StopIOSDeviceRecording(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), stopIOSDeviceRecording());
+}
+
+Napi::Value GetIOSDeviceRecordingStatus(const Napi::CallbackInfo& info) {
+    Napi::Object status = Napi::Object::New(info.Env());
+    status.Set("isRecording", Napi::Boolean::New(info.Env(), isIOSDeviceRecording()));
+    NSString *path = currentIOSDeviceRecordingPath();
+    if (path.length > 0) status.Set("outputPath", Napi::String::New(info.Env(), [path UTF8String]));
+    return status;
+}
+
+Napi::Object InitIOSDeviceRecorder(Napi::Env env, Napi::Object exports) {
+    exports.Set("getIOSCaptureDevices", Napi::Function::New(env, GetIOSCaptureDevices));
+    exports.Set("startIOSDeviceRecording", Napi::Function::New(env, StartIOSDeviceRecording));
+    exports.Set("stopIOSDeviceRecording", Napi::Function::New(env, StopIOSDeviceRecording));
+    exports.Set("getIOSDeviceRecordingStatus", Napi::Function::New(env, GetIOSDeviceRecordingStatus));
+    return exports;
+}

package/src/mac_recorder.mm

@@ -55,6 +55,9 @@ Napi::Object InitKeyboardTracker(Napi::Env env, Napi::Object exports);
 // Window selector function declarations
 Napi::Object InitWindowSelector(Napi::Env env, Napi::Object exports);
 
+// USB iPhone/iPad screen capture functions
+Napi::Object InitIOSDeviceRecorder(Napi::Env env, Napi::Object exports);
+
 // Window selector overlay functions (external)
 extern "C" void hideOverlays();
 extern "C" void showOverlays();
@@ -1779,6 +1782,9 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
 
     // Initialize window selector
     InitWindowSelector(env, exports);
+
+    // Initialize direct USB iPhone/iPad capture
+    InitIOSDeviceRecorder(env, exports);
     
     return exports;
 }

package/src/sync_timeline.h

@@ -32,6 +32,14 @@ void MRSyncConfigureCamera(BOOL expectCamera);
 void MRSyncMarkCameraFirstFrame(CMTime timestamp);
 BOOL MRSyncShouldHoldAudioSample(CMTime timestamp);
 
+// Some primary sources (for example a USB iPhone muxed device) need a short
+// asynchronous warm-up before their first frame is committed. Camera and
+// microphone writers can use this barrier to discard their warm-up samples and
+// begin at the same host-clock instant as that primary source.
+void MRSyncConfigurePrimaryStart(BOOL expectPrimary);
+void MRSyncMarkPrimaryStarted(CMTime timestamp);
+BOOL MRSyncShouldHoldForPrimary(CMTime timestamp);
+
 // Optional hard stop limit (seconds) shared across capture components.
 void MRSyncSetStopLimitSeconds(double seconds);
 double MRSyncGetStopLimitSeconds(void);

package/src/sync_timeline.mm

@@ -25,6 +25,13 @@ static CMTime g_cameraFirstTimestamp = kCMTimeInvalid;
 static CMTime g_audioHoldFirstTimestamp = kCMTimeInvalid;
 static BOOL g_audioHoldLogged = NO;
 
+// Primary-source start barrier (USB iPhone screen capture, etc.).
+static BOOL g_expectPrimary = NO;
+static BOOL g_primaryReady = YES;
+static CMTime g_primaryStartTimestamp = kCMTimeInvalid;
+static CMTime g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+static BOOL g_primaryHoldLogged = NO;
+
 void MRSyncConfigure(BOOL expectAudio) {
     dispatch_sync(MRSyncQueue(), ^{
         g_expectAudio = expectAudio;
@@ -40,6 +47,11 @@ void MRSyncConfigure(BOOL expectAudio) {
         g_cameraFirstTimestamp = kCMTimeInvalid;
         g_audioHoldFirstTimestamp = kCMTimeInvalid;
         g_audioHoldLogged = NO;
+        g_expectPrimary = NO;
+        g_primaryReady = YES;
+        g_primaryStartTimestamp = kCMTimeInvalid;
+        g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+        g_primaryHoldLogged = NO;
     });
 }
 
@@ -245,6 +257,82 @@ BOOL MRSyncShouldHoldAudioSample(CMTime timestamp) {
     return shouldHold;
 }
 
+void MRSyncConfigurePrimaryStart(BOOL expectPrimary) {
+    dispatch_sync(MRSyncQueue(), ^{
+        g_expectPrimary = expectPrimary;
+        g_primaryReady = expectPrimary ? NO : YES;
+        g_primaryStartTimestamp = kCMTimeInvalid;
+        g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+        g_primaryHoldLogged = NO;
+    });
+    if (expectPrimary) {
+        MRLog(@"🔄 A/V SYNC: Primary-source start barrier enabled");
+    }
+}
+
+void MRSyncMarkPrimaryStarted(CMTime timestamp) {
+    if (!CMTIME_IS_VALID(timestamp)) return;
+
+    __block BOOL logRelease = NO;
+    dispatch_sync(MRSyncQueue(), ^{
+        if (g_primaryReady) return;
+        g_primaryStartTimestamp = timestamp;
+        g_primaryReady = YES;
+        g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+        g_primaryHoldLogged = NO;
+        logRelease = YES;
+    });
+    if (logRelease) {
+        MRLog(@"🎯 A/V SYNC: Primary source started - releasing camera and microphone");
+    }
+}
+
+BOOL MRSyncShouldHoldForPrimary(CMTime timestamp) {
+    if (!CMTIME_IS_VALID(timestamp)) return NO;
+
+    __block BOOL shouldHold = NO;
+    __block BOOL logHold = NO;
+    __block BOOL logRelease = NO;
+    dispatch_sync(MRSyncQueue(), ^{
+        if (!g_expectPrimary || g_primaryReady) {
+            if (CMTIME_IS_VALID(g_primaryStartTimestamp) &&
+                CMTIME_COMPARE_INLINE(timestamp, <, g_primaryStartTimestamp)) {
+                shouldHold = YES;
+            }
+            return;
+        }
+
+        if (!CMTIME_IS_VALID(g_primaryHoldFirstTimestamp)) {
+            g_primaryHoldFirstTimestamp = timestamp;
+            shouldHold = YES;
+            if (!g_primaryHoldLogged) {
+                g_primaryHoldLogged = YES;
+                logHold = YES;
+            }
+            return;
+        }
+
+        // Fail open if a future primary source forgets to signal start.
+        CMTime elapsed = CMTimeSubtract(timestamp, g_primaryHoldFirstTimestamp);
+        if (CMTIME_COMPARE_INLINE(elapsed, >, CMTimeMakeWithSeconds(12.0, 600))) {
+            g_primaryReady = YES;
+            g_primaryHoldFirstTimestamp = kCMTimeInvalid;
+            g_primaryHoldLogged = NO;
+            shouldHold = NO;
+            logRelease = YES;
+            return;
+        }
+        shouldHold = YES;
+    });
+
+    if (logHold) {
+        MRLog(@"⏸️ A/V SYNC: Camera/microphone waiting for primary source");
+    } else if (logRelease) {
+        MRLog(@"▶️ A/V SYNC: Primary-source hold released by safety timeout");
+    }
+    return shouldHold;
+}
+
 void MRSyncSetStopLimitSeconds(double seconds) {
     dispatch_sync(MRSyncQueue(), ^{
         g_stopLimitSeconds = seconds;

package/src/window_selector.mm

@@ -898,10 +898,57 @@ bool activateWindowOwnerApp(int windowId) {
     }
 }
 
+// Hedef pencerenin sahibi uygulamayi ONE ALIR (Accessibility GEREKTIRMEZ).
+// bringWindowToFront'un AX yolu izin isterken bu yol yalnizca
+// NSRunningApplication kullanir; izin yokken tek calisan yol budur.
+static bool activateOwnerAppForWindow(int windowId) {
+    @autoreleasepool {
+        // Method 2: Light activation fallback (minimal app activation)
+        NSLog(@"   🔄 Trying minimal activation for window %d", windowId);
+    
+        // Get window info to find the process
+        CFArrayRef cgWindowList = CGWindowListCopyWindowInfo(kCGWindowListOptionAll, kCGNullWindowID);
+        if (cgWindowList) {
+            NSArray *windowArray = (__bridge NSArray *)cgWindowList;
+        
+            for (NSDictionary *windowInfo in windowArray) {
+                NSNumber *cgWindowId = [windowInfo objectForKey:(NSString *)kCGWindowNumber];
+                if ([cgWindowId intValue] == windowId) {
+                    // Get process ID
+                    NSNumber *processId = [windowInfo objectForKey:(NSString *)kCGWindowOwnerPID];
+                    if (processId) {
+                        // Light activation - only bring app to front, don't activate all windows
+                        NSRunningApplication *app = [NSRunningApplication runningApplicationWithProcessIdentifier:[processId intValue]];
+                        if (app) {
+                            // Use NSApplicationActivateIgnoringOtherApps only (no NSApplicationActivateAllWindows)
+                            [app activateWithOptions:NSApplicationActivateIgnoringOtherApps];
+                            NSLog(@"   ✅ App minimally activated: PID %d (specific window should be frontmost)", [processId intValue]);
+                            CFRelease(cgWindowList);
+                            return true;
+                        }
+                    }
+                    break;
+                }
+            }
+            CFRelease(cgWindowList);
+        }
+        return false;
+    }
+}
+
 // Bring window to front using Accessibility API
 bool bringWindowToFront(int windowId) {
     @autoreleasepool {
         @try {
+            // TCC istemi CIKMASIN: untrusted bir surecin systemWide element
+            // uzerindeki AX cagrilari macOS'a "Erisilebilirlik" dialogunu
+            // actiriyor — pencere kaydi HER baslatildiginda yeniden. Izin yoksa
+            // AX yolunu hic deneme; hafif aktivasyon zaten ayni isi goruyor.
+            // AXIsProcessTrusted() kendisi istem GOSTERMEZ.
+            if (!AXIsProcessTrusted()) {
+                return activateOwnerAppForWindow(windowId);
+            }
+
             // Method 1: Using Accessibility API (most reliable)
             AXUIElementRef systemWide = AXUIElementCreateSystemWide();
             if (!systemWide) return false;
@@ -965,35 +1012,8 @@ bool bringWindowToFront(int windowId) {
             
             CFRelease(systemWide);
             
-            // Method 2: Light activation fallback (minimal app activation)
-            NSLog(@"   🔄 Trying minimal activation for window %d", windowId);
-            
-            // Get window info to find the process
-            CFArrayRef cgWindowList = CGWindowListCopyWindowInfo(kCGWindowListOptionAll, kCGNullWindowID);
-            if (cgWindowList) {
-                NSArray *windowArray = (__bridge NSArray *)cgWindowList;
-                
-                for (NSDictionary *windowInfo in windowArray) {
-                    NSNumber *cgWindowId = [windowInfo objectForKey:(NSString *)kCGWindowNumber];
-                    if ([cgWindowId intValue] == windowId) {
-                        // Get process ID
-                        NSNumber *processId = [windowInfo objectForKey:(NSString *)kCGWindowOwnerPID];
-                        if (processId) {
-                            // Light activation - only bring app to front, don't activate all windows
-                            NSRunningApplication *app = [NSRunningApplication runningApplicationWithProcessIdentifier:[processId intValue]];
-                            if (app) {
-                                // Use NSApplicationActivateIgnoringOtherApps only (no NSApplicationActivateAllWindows)
-                                [app activateWithOptions:NSApplicationActivateIgnoringOtherApps];
-                                NSLog(@"   ✅ App minimally activated: PID %d (specific window should be frontmost)", [processId intValue]);
-                                CFRelease(cgWindowList);
-                                return true;
-                            }
-                        }
-                        break;
-                    }
-                }
-                CFRelease(cgWindowList);
-            }
+            // AX yolu pencereyi bulamadi → izinsiz de calisan hafif aktivasyon.
+            if (activateOwnerAppForWindow(windowId)) return true;
             
             return false;