@expo/serve-sim 0.13.1 → 0.13.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/serve-sim",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "homepage": "https://github.com/expo/expo-device-hub/tree/main/packages/serve-sim/packages/serve-sim",
   "bugs": {
     "url": "https://github.com/expo/expo-device-hub/issues"

package/src/middleware.ts

@@ -3,8 +3,10 @@ export { startDeviceInProcess } from "./device-lifecycle";
 export { gridDeviceState } from "./state";
 import { SingleDevicePolicy } from "./single-device";
 import { getScreenshotDisplayIdsAsync } from "./screenshot-display";
+import { ScreenshotParams } from "./host-actions";
 import {
   captureScreenshotFileAsync,
+  captureNativeScreenshotAsync,
   ScreenshotDisplay,
   SCREENSHOT_DISPLAY_CHANGED,
 } from "./screenshot-store";
@@ -2128,6 +2130,7 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
   const ALWAYS_GATED_PREFIX = "/network-capture";
 
   const connectMiddleware = (async (req: SimReq, res: SimRes, next?: SimNext) => {
+    const requestStarted = performance.now();
     const rawUrl: string = req.url ?? "";
     const qIndex = rawUrl.indexOf("?");
     const url = qIndex === -1 ? rawUrl : rawUrl.slice(0, qIndex);
@@ -2797,7 +2800,7 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
       return;
     }
 
-    // Still-PNG capture via `simctl io <udid> screenshot`. Consumed by the
+    // Still-PNG capture from native pixels (explicit displays use simctl). Consumed by the
     // Expo Device Hub dashboard's save-screenshot action and by the serve-sim web
     // UI when it is served through a tunnel (on loopback it uses the
     // screenshot.capture host action instead). Uses the
@@ -2842,18 +2845,46 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
       }
       udid = udid.toUpperCase();
       // HTTP downloads avoid staging and Desktop copies, but share panel election.
-      const file = join(tmpdir(), `serve-sim-screenshot-${randomBytes(8).toString("hex")}.png`);
+      let file: string | undefined;
       try {
+        const captureStarted = performance.now();
+        let nativeDuration = 0;
         const screenId = display?.data;
-        const capture = (id: number, read?: () => Promise<number>) =>
-          captureScreenshotFileAsync({ udid, file, display: id, timeoutMs: 5_000 }, read);
-        const result =
+        const capture = async (id: number) => {
+          file ??= join(tmpdir(), `serve-sim-screenshot-${randomBytes(8).toString("hex")}.png`);
+          const result = await captureScreenshotFileAsync({
+            udid,
+            file,
+            display: id,
+            timeoutMs: 5_000,
+          });
+          if (result.exitCode !== 0)
+            throw new Error(result.stderr || "Simulator screenshot failed");
+          return await readFile(file);
+        };
+        const png =
           screenId !== undefined
             ? await capture(screenId)
             : await withScreenshotDeviceSession(udid, streamSettings, async (session) => {
                 const read = () => session.activeScreenId();
-                return await capture(await read(), read);
+                return Buffer.from(
+                  await captureNativeScreenshotAsync(
+                    await read(),
+                    read,
+                    async (id, timeoutMs) => {
+                      const started = performance.now();
+                      try {
+                        return await session.screenshot(id, timeoutMs);
+                      } finally {
+                        nativeDuration += performance.now() - started;
+                      }
+                    },
+                    5_000,
+                  ),
+                );
               }).catch(async (error) => {
+                if (error instanceof Error && error.message === SCREENSHOT_DISPLAY_CHANGED)
+                  throw error;
                 // A sole integrated display needs no native panel election. Never
                 // fall back on an unknown profile or a multi-display device.
                 if (!(await getBootedUdids())?.has(udid)) throw error;
@@ -2861,15 +2892,21 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
                 if (ids?.length !== 1) throw error;
                 return await capture(ids[0]!);
               });
-        if (result.exitCode !== 0) throw new Error(result.stderr || "simctl screenshot failed");
-        const png = await readFile(file);
+        const captureDuration = performance.now() - captureStarted;
+        const artifactStarted = performance.now();
         const artifact = await saveScreenshotArtifact(png);
         recordScreenshotEvent(udid, artifact);
+        const artifactDuration = performance.now() - artifactStarted;
+        // Capture includes native queueing/PNG encoding; simctl also uses temporary-file I/O.
+        // Total stops before response delivery; durations overlap, so do not add them.
+        const serverTiming = `total;dur=${(performance.now() - requestStarted).toFixed(3)}, capture;dur=${captureDuration.toFixed(3)}, native;dur=${nativeDuration.toFixed(3)}, artifact;dur=${artifactDuration.toFixed(3)}`;
         res.writeHead(200, {
           "Cache-Control": "no-store",
           "Content-Type": "image/png",
+          "Content-Length": String(png.byteLength),
           // The route allows configured cross-origin callers, and they can only read custom headers listed here.
-          "Access-Control-Expose-Headers": `${SCREENSHOT_ARTIFACT_HEADER}, ${SCREENSHOT_ARTIFACT_ERROR_HEADER}`,
+          "Access-Control-Expose-Headers": `${SCREENSHOT_ARTIFACT_HEADER}, ${SCREENSHOT_ARTIFACT_ERROR_HEADER}, Server-Timing`,
+          "Server-Timing": serverTiming,
           ...screenshotArtifactHeaders(artifact),
         });
         res.end(png);
@@ -2879,7 +2916,7 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
           (typeof stderr === "string" && stderr.trim()) ||
           (err instanceof Error ? err.message : String(err));
         // The event log is browser-readable; simctl's stderr can name host paths, so it stays here.
-        console.error(`simctl screenshot failed for ${udid}:`, message);
+        console.error(`Simulator screenshot failed for ${udid}:`, message);
         recordScreenshotEvent(udid, {
           status: "capture-failed",
           error: "simctl screenshot failed",
@@ -2899,7 +2936,7 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
         );
       } finally {
         // Best-effort cleanup; the PNG is already in memory by now.
-        await unlink(file).catch(() => {});
+        if (file) await unlink(file).catch(() => {});
       }
       return;
     }
@@ -3449,6 +3486,29 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
     corsOrigins,
     ssePrefixes: sseStreamPaths(base),
     onUiRequest: handleUiRequest,
+    async onScreenshotRequest(payload, request) {
+      const parsed = ScreenshotParams.omit({ fileName: true })
+        .partial({ udid: true })
+        .strict()
+        .safeParse(payload);
+      if (!parsed.success)
+        return Response.json({ error: "Invalid screenshot request" }, { status: 400 });
+      const url = new URL(`${base}/api/screenshot`, request.url);
+      if (parsed.data.udid !== undefined) {
+        const { resolveBootedDeviceAsync } = await import("./device");
+        // Enforce the same target policy as ordinary actions before resolving aliases.
+        policy?.resolveTarget(parsed.data.udid);
+        url.searchParams.set("device", await resolveBootedDeviceAsync(parsed.data.udid));
+      }
+      if (parsed.data.display !== undefined)
+        url.searchParams.set("display", String(parsed.data.display));
+      return (await fetchMiddleware(
+        new Request(url, {
+          method: "POST",
+          headers: { authorization: `Bearer ${execToken}` },
+        }),
+      ))!;
+    },
     get unavailable() {
       return configuringSession || awaitingAdoption;
     },

package/src/native.ts

@@ -61,6 +61,7 @@ interface SimHIDHandle {
 }
 
 interface SimCaptureHandle {
+  screenshot(screenID: number): Promise<Uint8Array>;
   start(): Promise<void>;
   suspendForReboot(): Promise<void>;
   resumeAfterReboot(): Promise<void>;
@@ -394,6 +395,10 @@ export class NativeHid {
  * thread after being marshalled from the native encode thread.
  */
 export class NativeCapture {
+  screenshot(screenID: number): Promise<Uint8Array> {
+    return this.handle.screenshot(screenID);
+  }
+
   private readonly handle: SimCaptureHandle;
 
   /** A fixed screen ID captures that panel independently of active-display/input routing. */