browsertime 26.3.1 → 27.0.0

package/lib/safari/native/ios-capture.m

@@ -0,0 +1,340 @@
+/*
+ * iOS screen capture server for Browsertime.
+ *
+ * Enables CoreMediaIO screen capture devices, finds the connected iOS device,
+ * and accepts commands via stdin to start/stop recording.
+ *
+ * Commands (via stdin):
+ *   START <filepath>   - Start recording to the given file path
+ *   STOP               - Stop recording
+ *   QUIT               - Stop recording and exit
+ *
+ * Responses (via stdout):
+ *   READY              - Device found, ready to accept commands
+ *   RECORDING          - Recording started
+ *   STOPPED            - Recording stopped, file written
+ *   ERROR <message>    - An error occurred
+ *
+ * Compile:
+ *   clang -framework CoreMediaIO -framework AVFoundation -framework CoreVideo \
+ *         -framework CoreMedia -framework Foundation ios-capture.m -o ios-capture
+ */
+
+#import <Foundation/Foundation.h>
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMediaIO/CMIOHardwareSystem.h>
+#import <CoreMediaIO/CMIOHardwareDevice.h>
+#import <CoreVideo/CoreVideo.h>
+#import <CoreMedia/CoreMedia.h>
+#import <signal.h>
+#import <unistd.h>
+
+static volatile sig_atomic_t shouldQuit = 0;
+
+/*
+ * Signal handler: set the quit flag and close stdin so the main loop's
+ * blocking fgets() returns immediately. We can't safely call AVFoundation
+ * teardown from a signal handler, so we just unblock the loop and let
+ * main() do the [session stopRunning] / pclose on its way out.
+ * close() is async-signal-safe per POSIX.
+ */
+void handleSignal(int sig) {
+    shouldQuit = 1;
+    close(STDIN_FILENO);
+}
+
+/*
+ * Enumerate all CoreMediaIO devices directly (bypasses AVFoundation filtering)
+ * and return their unique IDs. On modern macOS, AVCaptureDeviceDiscoverySession
+ * sometimes hides iOS devices that CMIO has registered; iterating CMIO directly
+ * is the most reliable way to discover them.
+ */
+static NSArray<NSString *> *enumerateCMIODeviceUIDs(void) {
+    NSMutableArray<NSString *> *uids = [NSMutableArray array];
+
+    CMIOObjectPropertyAddress addr = {
+        kCMIOHardwarePropertyDevices,
+        kCMIOObjectPropertyScopeGlobal,
+        kCMIOObjectPropertyElementMain
+    };
+
+    UInt32 dataSize = 0;
+    if (CMIOObjectGetPropertyDataSize(kCMIOObjectSystemObject, &addr, 0, NULL, &dataSize) != 0) {
+        return uids;
+    }
+    UInt32 count = dataSize / sizeof(CMIOObjectID);
+    if (count == 0) return uids;
+
+    CMIOObjectID *deviceIDs = (CMIOObjectID *)malloc(dataSize);
+    if (CMIOObjectGetPropertyData(kCMIOObjectSystemObject, &addr, 0, NULL, dataSize, &dataSize, deviceIDs) != 0) {
+        free(deviceIDs);
+        return uids;
+    }
+
+    for (UInt32 i = 0; i < count; i++) {
+        CFStringRef uid = NULL;
+        UInt32 propSize = sizeof(uid);
+        CMIOObjectPropertyAddress uidAddr = {
+            kCMIODevicePropertyDeviceUID,
+            kCMIOObjectPropertyScopeGlobal,
+            kCMIOObjectPropertyElementMain
+        };
+        if (CMIOObjectGetPropertyData(deviceIDs[i], &uidAddr, 0, NULL, propSize, &propSize, &uid) == 0 && uid) {
+            [uids addObject:(__bridge NSString *)uid];
+            CFRelease(uid);
+        }
+    }
+    free(deviceIDs);
+    return uids;
+}
+
+/*
+ * Try to find an iOS device by checking every plausible AVCaptureDeviceType
+ * AND every UID reported by CMIO directly. Returns the first device whose
+ * media type includes muxed (audio+video) — the signature of an iOS device.
+ */
+static AVCaptureDevice *findIOSCaptureDevice(void) {
+    NSArray<AVCaptureDeviceType> *types = @[
+        AVCaptureDeviceTypeExternal,
+        AVCaptureDeviceTypeContinuityCamera,
+        AVCaptureDeviceTypeBuiltInWideAngleCamera,
+        AVCaptureDeviceTypeDeskViewCamera
+    ];
+    NSArray<AVMediaType> *medias = @[AVMediaTypeMuxed, AVMediaTypeVideo];
+
+    for (AVCaptureDeviceType t in types) {
+        for (AVMediaType m in medias) {
+            AVCaptureDeviceDiscoverySession *ds = [AVCaptureDeviceDiscoverySession
+                discoverySessionWithDeviceTypes:@[t]
+                mediaType:m
+                position:AVCaptureDevicePositionUnspecified];
+            for (AVCaptureDevice *d in ds.devices) {
+                if ([d hasMediaType:AVMediaTypeMuxed]) {
+                    return d;
+                }
+            }
+        }
+    }
+
+    /* Fallback: bridge each CMIO UID to AVCaptureDevice and pick a muxed one */
+    for (NSString *uid in enumerateCMIODeviceUIDs()) {
+        AVCaptureDevice *d = [AVCaptureDevice deviceWithUniqueID:uid];
+        if (d && [d hasMediaType:AVMediaTypeMuxed]) {
+            fprintf(stderr, "Found iOS device via CMIO bridge: %s (uid=%s)\n",
+                    [[d localizedName] UTF8String], [uid UTF8String]);
+            return d;
+        }
+    }
+
+    return nil;
+}
+
+@interface Recorder : NSObject <AVCaptureVideoDataOutputSampleBufferDelegate>
+@property (nonatomic, strong) AVCaptureSession *session;
+@property (nonatomic, assign) int frameCount;
+@property (nonatomic, assign) int width;
+@property (nonatomic, assign) int height;
+@property (nonatomic, assign) BOOL isRecording;
+@property (nonatomic, assign) FILE *ffmpegPipe;
+@property (nonatomic, assign) int framerate;
+@end
+
+@implementation Recorder
+
+- (void)captureOutput:(AVCaptureOutput *)output
+    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
+    fromConnection:(AVCaptureConnection *)connection {
+
+    CVImageBufferRef imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+    if (!imageBuffer) return;
+
+    CVPixelBufferLockBaseAddress(imageBuffer, kCVPixelBufferLock_ReadOnly);
+
+    size_t width = CVPixelBufferGetWidth(imageBuffer);
+    size_t height = CVPixelBufferGetHeight(imageBuffer);
+
+    /* Always update dimensions from incoming frames */
+    if (self.width == 0) {
+        self.width = (int)width;
+        self.height = (int)height;
+        fprintf(stderr, "Device resolution: %dx%d\n", self.width, self.height);
+    }
+
+    /* Only write frames when recording */
+    if (self.isRecording && self.ffmpegPipe) {
+        size_t bytesPerRow = CVPixelBufferGetBytesPerRow(imageBuffer);
+        void *baseAddress = CVPixelBufferGetBaseAddress(imageBuffer);
+        if (baseAddress) {
+            for (size_t row = 0; row < height; row++) {
+                fwrite((uint8_t *)baseAddress + row * bytesPerRow, 1, width * 4, self.ffmpegPipe);
+            }
+            self.frameCount++;
+        }
+    }
+
+    CVPixelBufferUnlockBaseAddress(imageBuffer, kCVPixelBufferLock_ReadOnly);
+}
+
+- (BOOL)startRecordingToFile:(NSString *)path {
+    if (self.isRecording) {
+        [self stopRecording];
+    }
+
+    self.frameCount = 0;
+
+    /* Wait for dimensions if we haven't seen a frame yet */
+    if (self.width == 0) {
+        fprintf(stderr, "Waiting for first frame...\n");
+        for (int i = 0; i < 100 && self.width == 0; i++) {
+            [NSThread sleepForTimeInterval:0.1];
+        }
+        if (self.width == 0) {
+            fprintf(stderr, "Could not determine video dimensions\n");
+            return NO;
+        }
+    }
+
+    int evenWidth = (self.width / 2) * 2;
+    int evenHeight = (self.height / 2) * 2;
+
+    NSString *cmd = [NSString stringWithFormat:
+        @"ffmpeg -f rawvideo -pix_fmt bgra -s %dx%d -r %d -i - "
+        @"-vf 'scale=%d:%d' "
+        @"-c:v libx264 -preset ultrafast -pix_fmt yuv420p -y '%@' 2>/dev/null",
+        self.width, self.height, self.framerate,
+        evenWidth, evenHeight,
+        path];
+
+    self.ffmpegPipe = popen([cmd UTF8String], "w");
+    if (!self.ffmpegPipe) {
+        fprintf(stderr, "Failed to start ffmpeg\n");
+        return NO;
+    }
+
+    self.isRecording = YES;
+    self.frameCount = 0;
+    return YES;
+}
+
+- (void)stopRecording {
+    self.isRecording = NO;
+
+    if (self.ffmpegPipe) {
+        pclose(self.ffmpegPipe);
+        self.ffmpegPipe = NULL;
+    }
+
+    fprintf(stderr, "Recorded %d frames\n", self.frameCount);
+}
+
+@end
+
+int main(int argc, const char *argv[]) {
+    @autoreleasepool {
+        signal(SIGINT, handleSignal);
+        signal(SIGTERM, handleSignal);
+
+        int framerate = 30;
+        for (int i = 1; i < argc; i++) {
+            if (strcmp(argv[i], "-r") == 0 && i + 1 < argc) {
+                framerate = atoi(argv[++i]);
+            }
+        }
+
+        /* Step 1: Enable screen capture devices */
+        CMIOObjectPropertyAddress prop = {
+            kCMIOHardwarePropertyAllowScreenCaptureDevices,
+            kCMIOObjectPropertyScopeGlobal,
+            kCMIOObjectPropertyElementMain
+        };
+        UInt32 allow = 1;
+        CMIOObjectSetPropertyData(kCMIOObjectSystemObject, &prop, 0, NULL, sizeof(allow), &allow);
+
+        /* Step 2: Warm up AVCaptureDevice */
+        #pragma clang diagnostic push
+        #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+        [AVCaptureDevice devices];
+        #pragma clang diagnostic pop
+        [NSThread sleepForTimeInterval:1.0];
+
+        /* Log what CMIO sees directly — useful when discovery fails */
+        NSArray<NSString *> *cmioUIDs = enumerateCMIODeviceUIDs();
+        fprintf(stderr, "CMIO reports %lu device(s)\n", (unsigned long)cmioUIDs.count);
+        for (NSString *uid in cmioUIDs) {
+            fprintf(stderr, "  CMIO UID: %s\n", [uid UTF8String]);
+        }
+
+        /* Step 3: Find iOS device — multi-type filter + CMIO bridge fallback */
+        AVCaptureDevice *device = nil;
+        for (int attempt = 0; attempt < 20 && !device; attempt++) {
+            device = findIOSCaptureDevice();
+            if (!device) [NSThread sleepForTimeInterval:0.5];
+        }
+
+        if (!device) {
+            fprintf(stdout, "ERROR No iOS device found\n");
+            fflush(stdout);
+            return 1;
+        }
+
+        fprintf(stderr, "Found device: %s\n", [[device localizedName] UTF8String]);
+
+        /* Step 4: Set up capture session */
+        AVCaptureSession *session = [[AVCaptureSession alloc] init];
+        NSError *error = nil;
+        AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
+        if (!input) {
+            fprintf(stdout, "ERROR Failed to create capture input\n");
+            fflush(stdout);
+            return 1;
+        }
+        [session addInput:input];
+
+        AVCaptureVideoDataOutput *videoOutput = [[AVCaptureVideoDataOutput alloc] init];
+        videoOutput.videoSettings = @{
+            (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)
+        };
+
+        Recorder *recorder = [[Recorder alloc] init];
+        recorder.framerate = framerate;
+
+        dispatch_queue_t queue = dispatch_queue_create("capture", DISPATCH_QUEUE_SERIAL);
+        [videoOutput setSampleBufferDelegate:recorder queue:queue];
+        [session addOutput:videoOutput];
+
+        [session startRunning];
+
+        /* Signal ready */
+        fprintf(stdout, "READY\n");
+        fflush(stdout);
+
+        /* Step 5: Read commands from stdin */
+        char line[4096];
+        while (!shouldQuit && fgets(line, sizeof(line), stdin)) {
+            /* Remove newline */
+            size_t len = strlen(line);
+            if (len > 0 && line[len-1] == '\n') line[len-1] = '\0';
+
+            if (strncmp(line, "START ", 6) == 0) {
+                NSString *path = [NSString stringWithUTF8String:line + 6];
+                if ([recorder startRecordingToFile:path]) {
+                    fprintf(stdout, "RECORDING\n");
+                } else {
+                    fprintf(stdout, "ERROR Failed to start recording\n");
+                }
+                fflush(stdout);
+            } else if (strcmp(line, "STOP") == 0) {
+                [recorder stopRecording];
+                fprintf(stdout, "STOPPED\n");
+                fflush(stdout);
+            } else if (strcmp(line, "QUIT") == 0) {
+                [recorder stopRecording];
+                shouldQuit = YES;
+            }
+        }
+
+        [recorder stopRecording];
+        [session stopRunning];
+        return 0;
+    }
+}

package/lib/safari/safariInspectorClient.js

@@ -0,0 +1,322 @@
+/* global WebSocket */
+import { execa } from 'execa';
+import { getLogger } from '@sitespeed.io/log';
+
+const log = getLogger('browsertime.safari.inspector');
+
+export class SafariInspectorClient {
+  constructor(options) {
+    this.options = options;
+    this.safariOptions = options.safari || {};
+    this.port = options.iwdpPort || 9222;
+    this.connections = [];
+    this.targetId = undefined;
+    this.targetWs = undefined; // The WebSocket that owns the active target
+    this.pinnedWs = undefined; // When set, only this ws may set targetId
+    this.messageId = 0;
+    this.pendingMessages = new Map();
+    this.eventListeners = new Map();
+    this.iwdpProcess = undefined;
+  }
+
+  async setup(targetMatcher) {
+    await this._verifyIwdpInstalled();
+    await this._startIwdp();
+    await this._waitForIwdp();
+    await this._connectWebSockets(targetMatcher);
+    await this._waitForTarget();
+  }
+
+  async _verifyIwdpInstalled() {
+    try {
+      await execa('which', ['ios_webkit_debug_proxy']);
+    } catch {
+      throw new Error(
+        'ios_webkit_debug_proxy is not installed. Install it with: brew install ios-webkit-debug-proxy'
+      );
+    }
+  }
+
+  async _startIwdp() {
+    const args = ['-F'];
+    if (this.safariOptions.deviceUDID) {
+      args.push('-u', this.safariOptions.deviceUDID);
+    }
+    log.debug('Starting ios_webkit_debug_proxy on port %d', this.port);
+    this.iwdpProcess = execa('ios_webkit_debug_proxy', args, {
+      stdio: 'ignore'
+    });
+    this.iwdpProcess.catch(error => {
+      if (!error.isCanceled) {
+        log.error('ios_webkit_debug_proxy failed: %s', error.message);
+      }
+    });
+  }
+
+  async _waitForIwdp() {
+    const maxRetries = 20;
+    const retryDelay = 500;
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        const response = await fetch(`http://localhost:${this.port}/json`);
+        if (response.ok) {
+          log.debug('ios_webkit_debug_proxy is ready');
+          return;
+        }
+      } catch {
+        // Not ready yet
+      }
+      await new Promise(r => setTimeout(r, retryDelay));
+    }
+    throw new Error(
+      `ios_webkit_debug_proxy did not start within ${(maxRetries * retryDelay) / 1000} seconds`
+    );
+  }
+
+  async _connectWebSockets(targetMatcher) {
+    const response = await fetch(`http://localhost:${this.port}/json`);
+    const pages = await response.json();
+
+    for (const page of pages) {
+      if (!page.webSocketDebuggerUrl) continue;
+      try {
+        const ws = await new Promise((resolve, reject) => {
+          const socket = new WebSocket(page.webSocketDebuggerUrl);
+          socket.addEventListener('open', () => resolve(socket));
+          socket.addEventListener('error', () =>
+            reject(new Error('WebSocket error'))
+          );
+          setTimeout(() => reject(new Error('timeout')), 5000);
+        });
+
+        // Pin BEFORE the message listener is attached so the very first
+        // Target.targetCreated from any other tab cannot set targetId.
+        if (targetMatcher && targetMatcher(page)) {
+          this.pinnedWs = ws;
+        }
+
+        ws.addEventListener('message', event => {
+          this._handleMessage(ws, JSON.parse(event.data));
+        });
+
+        this.connections.push({ ws, page });
+        log.debug('Connected to page: %s', page.title || page.url || 'unknown');
+      } catch {
+        // Skip pages we can't connect to
+      }
+    }
+
+    if (this.connections.length === 0) {
+      throw new Error(
+        'No inspectable Safari pages found via ios_webkit_debug_proxy'
+      );
+    }
+
+    if (targetMatcher && !this.pinnedWs) {
+      log.warn(
+        'Could not identify the WebDriver Safari tab via iWDP — HAR may be empty if other tabs are open on the device'
+      );
+    }
+    log.debug('Connected to %d inspectable pages', this.connections.length);
+  }
+
+  async _waitForTarget() {
+    // Wait for targetCreated events
+    await new Promise(r => setTimeout(r, 1500));
+
+    if (this.targetId) {
+      log.debug('Network and Page enabled on target %s', this.targetId);
+    } else {
+      log.debug(
+        'No page target found yet — will enable Network when a target appears'
+      );
+    }
+  }
+
+  _handleMessage(ws, msg) {
+    // Handle Target.targetCreated — auto-enable Network on new page targets
+    if (msg.method === 'Target.targetCreated') {
+      const target = msg.params?.targetInfo;
+      if (target?.type === 'page') {
+        // If we've pinned the WebDriver-controlled tab, ignore targetCreated
+        // from unrelated tabs so they can't clobber the active target.
+        if (this.pinnedWs && ws !== this.pinnedWs) return;
+        this.targetId = target.targetId;
+        this.targetWs = ws; // Remember which WebSocket owns this target
+        log.debug('Found page target: %s', this.targetId);
+        // Enable Network and Page on this target immediately
+        this._sendOnWs(ws, 'Target.sendMessageToTarget', {
+          targetId: target.targetId,
+          message: JSON.stringify({
+            id: ++this.messageId,
+            method: 'Network.enable',
+            params: {}
+          })
+        });
+        this._sendOnWs(ws, 'Target.sendMessageToTarget', {
+          targetId: target.targetId,
+          message: JSON.stringify({
+            id: ++this.messageId,
+            method: 'Page.enable',
+            params: {}
+          })
+        });
+      }
+    }
+
+    // Unwrap Target.dispatchMessageFromTarget — only from the active target
+    if (msg.method === 'Target.dispatchMessageFromTarget') {
+      try {
+        const innerMsg = JSON.parse(msg.params.message);
+        // Only dispatch events from the active target to avoid cross-tab noise
+        const fromTargetId = msg.params.targetId;
+        if (innerMsg.method && fromTargetId === this.targetId) {
+          const listeners = this.eventListeners.get(innerMsg.method) || [];
+          for (const cb of listeners) {
+            cb(innerMsg.params);
+          }
+        }
+        // Resolve pending commands
+        if (
+          innerMsg.id !== undefined &&
+          this.pendingMessages.has(innerMsg.id)
+        ) {
+          const { resolve } = this.pendingMessages.get(innerMsg.id);
+          this.pendingMessages.delete(innerMsg.id);
+          resolve(innerMsg);
+        }
+      } catch {
+        // Not valid JSON
+      }
+    }
+
+    // Resolve top-level responses
+    if (msg.id !== undefined && this.pendingMessages.has(msg.id)) {
+      const { resolve } = this.pendingMessages.get(msg.id);
+      this.pendingMessages.delete(msg.id);
+      resolve(msg);
+    }
+  }
+
+  /**
+   * Send a command to the active page target via Target.sendMessageToTarget.
+   */
+  async send(method, params = {}) {
+    if (!this.targetId || !this.targetWs) {
+      throw new Error('No target available for sending commands');
+    }
+    const innerId = ++this.messageId;
+    const innerMsg = JSON.stringify({ id: innerId, method, params });
+
+    return new Promise((resolve, reject) => {
+      this.pendingMessages.set(innerId, { resolve, reject });
+      try {
+        const outerId = ++this.messageId;
+        this.targetWs.send(
+          JSON.stringify({
+            id: outerId,
+            method: 'Target.sendMessageToTarget',
+            params: { targetId: this.targetId, message: innerMsg }
+          })
+        );
+      } catch (error) {
+        this.pendingMessages.delete(innerId);
+        reject(error);
+      }
+      setTimeout(() => {
+        if (this.pendingMessages.has(innerId)) {
+          this.pendingMessages.delete(innerId);
+          resolve({ error: 'timeout' });
+        }
+      }, 10_000);
+    });
+  }
+
+  /**
+   * Fire-and-forget send on a specific WebSocket.
+   */
+  _sendOnWs(ws, method, params) {
+    try {
+      ws.send(JSON.stringify({ id: ++this.messageId, method, params }));
+    } catch (error) {
+      log.debug('Send error: %s', error.message);
+    }
+  }
+
+  on(eventName, callback) {
+    if (!this.eventListeners.has(eventName)) {
+      this.eventListeners.set(eventName, []);
+    }
+    this.eventListeners.get(eventName).push(callback);
+  }
+
+  removeAllListeners() {
+    this.eventListeners.clear();
+  }
+
+  /**
+   * Reconnect to iwdp to discover new pages that appeared after initial setup.
+   * This is needed because safaridriver may create new tabs that weren't
+   * in the original page list.
+   */
+  async reconnect() {
+    const response = await fetch(`http://localhost:${this.port}/json`);
+    const pages = await response.json();
+
+    // Find pages we're not already connected to
+    const connectedUrls = new Set(
+      this.connections.map(c => c.page.webSocketDebuggerUrl)
+    );
+
+    for (const page of pages) {
+      if (!page.webSocketDebuggerUrl) continue;
+      if (connectedUrls.has(page.webSocketDebuggerUrl)) continue;
+
+      try {
+        const ws = await new Promise((resolve, reject) => {
+          const socket = new WebSocket(page.webSocketDebuggerUrl);
+          socket.addEventListener('open', () => resolve(socket));
+          socket.addEventListener('error', () =>
+            reject(new Error('WebSocket error'))
+          );
+          setTimeout(() => reject(new Error('timeout')), 3000);
+        });
+
+        ws.addEventListener('message', event => {
+          this._handleMessage(ws, JSON.parse(event.data));
+        });
+
+        this.connections.push({ ws, page });
+        log.debug(
+          'Reconnected to new page: %s (%s)',
+          page.title || 'untitled',
+          page.url || 'no url'
+        );
+      } catch {
+        // Skip
+      }
+    }
+  }
+
+  async close() {
+    for (const conn of this.connections) {
+      try {
+        conn.ws.close();
+      } catch {
+        // Ignore close errors
+      }
+    }
+    this.connections = [];
+    this.targetWs = undefined;
+    this.pinnedWs = undefined;
+    if (this.iwdpProcess) {
+      try {
+        this.iwdpProcess.kill();
+      } catch {
+        // Ignore kill errors
+      }
+      this.iwdpProcess = undefined;
+    }
+    log.debug('Safari inspector client closed');
+  }
+}