@expo/serve-sim 0.1.46 → 0.1.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/serve-sim",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "type": "module",
   "author": {
     "name": "Evan Bacon",

package/src/middleware.ts

@@ -954,6 +954,9 @@ export function previewConfigForState(
   streamSettingsEndpoint: string;
   serveSimBin: string;
   gridApiEndpoint: string;
+  gridCatalogEndpoint: string;
+  gridStatusEndpoint: string;
+  gridStatusEventsEndpoint: string;
   gridStartEndpoint: string;
   gridShutdownEndpoint: string;
   gridMemoryEndpoint: string;
@@ -983,6 +986,9 @@ export function previewConfigForState(
     streamSettingsEndpoint: streamSettingsEndpointFrom(state.streamUrl),
     serveSimBin,
     gridApiEndpoint: gridApiBase,
+    gridCatalogEndpoint: gridApiBase + "/catalog",
+    gridStatusEndpoint: gridApiBase + "/status",
+    gridStatusEventsEndpoint: gridApiBase + "/status/events",
     gridStartEndpoint: gridApiBase + "/start",
     gridShutdownEndpoint: gridApiBase + "/shutdown",
     gridMemoryEndpoint: gridApiBase + "/memory",
@@ -1168,6 +1174,81 @@ interface SimctlDevice {
   runtime: string;
 }
 
+type GridHelperStatus = Pick<ServeSimState, "port" | "url" | "streamUrl" | "wsUrl">;
+
+type GridCatalogDevice = {
+  device: string;
+  name: string;
+  runtime: string;
+  chrome: ReturnType<typeof resolveDeviceKitChrome>;
+  placeholderAsset: ReturnType<typeof resolveDevicePlaceholderAsset>;
+};
+
+type GridDeviceStatus = {
+  device: string;
+  state: string;
+  helper: GridHelperStatus | null;
+};
+
+// DeviceKit lookups are static for a simulator profile. Keep their descriptors
+// in-process so catalog page refreshes do not repeatedly rebuild the large
+// objects before JSON serialization.
+const gridCatalogDeviceCache = new Map<string, { signature: string; device: GridCatalogDevice }>();
+
+function catalogDeviceForSimulator(device: SimctlDevice): GridCatalogDevice {
+  const signature = [
+    device.name,
+    device.runtime,
+    device.deviceTypeIdentifier ?? "",
+  ].join("\0");
+  const cached = gridCatalogDeviceCache.get(device.udid);
+  if (cached?.signature === signature) return cached.device;
+  const catalogDevice: GridCatalogDevice = {
+    device: device.udid,
+    name: device.name,
+    runtime: device.runtime,
+    chrome: resolveDeviceKitChrome(device),
+    placeholderAsset: resolveDevicePlaceholderAsset(device),
+  };
+  gridCatalogDeviceCache.set(device.udid, { signature, device: catalogDevice });
+  return catalogDevice;
+}
+
+function sortGridSimulators(
+  simulators: SimctlDevice[],
+  helperByUdid: ReadonlyMap<string, ServeSimState>,
+  selectedDevice: string | null,
+): SimctlDevice[] {
+  const preferredUdid = getPreferredDeviceUdid();
+  const familyRank = (name: string): number => {
+    if (/iphone/i.test(name)) return 0;
+    if (/ipad/i.test(name)) return 1;
+    if (/watch/i.test(name)) return 2;
+    if (/(apple\s*tv|^tv\b)/i.test(name)) return 3;
+    if (/vision|reality/i.test(name)) return 4;
+    return 5;
+  };
+  const stateRank = (device: SimctlDevice): number => {
+    if (helperByUdid.has(device.udid)) return 0;
+    if (selectedDevice && device.udid === selectedDevice) return 1;
+    if (device.state === "Booted") return 2;
+    if (device.udid === preferredUdid) return 3;
+    return 4;
+  };
+  const runtimeRank = (runtime: string): number => {
+    const match = runtime.match(/-(\d+)-(\d+)/);
+    const major = match ? Number(match[1]) : 0;
+    const minor = match ? Number(match[2]) : 0;
+    return -(major * 1000 + minor);
+  };
+  return simulators.sort((a, b) =>
+    stateRank(a) - stateRank(b) ||
+    familyRank(a.name) - familyRank(b.name) ||
+    a.name.localeCompare(b.name) ||
+    runtimeRank(a.runtime) - runtimeRank(b.runtime),
+  );
+}
+
 function listAllSimulators(): Promise<SimctlDevice[]> {
   return new Promise((resolve) => {
     execFile(
@@ -1197,6 +1278,54 @@ function listAllSimulators(): Promise<SimctlDevice[]> {
   });
 }
 
+async function readGridSnapshot(selectedDevice: string | null): Promise<{
+  simulators: SimctlDevice[];
+  helperByUdid: Map<string, ServeSimState>;
+}> {
+  const [states, simulators] = await Promise.all([
+    readServeSimStates(),
+    listAllSimulators(),
+  ]);
+  const helperByUdid = new Map(states.map((state) => [state.device, state] as const));
+  return {
+    simulators: sortGridSimulators(simulators, helperByUdid, selectedDevice),
+    helperByUdid,
+  };
+}
+
+function gridStatusesForRequest(
+  simulators: readonly SimctlDevice[],
+  helperByUdid: ReadonlyMap<string, ServeSimState>,
+  req: SimReq,
+  base: string,
+  proxyHelpers: boolean,
+): GridDeviceStatus[] {
+  return simulators.map((simulator) => {
+    const helper = helperByUdid.get(simulator.udid);
+    const remoteHelper = helper
+      ? rewriteStateForRequestHost(
+          helper,
+          hostForRequest(req),
+          base,
+          httpProtocolForRequest(req),
+          proxyHelpers,
+        )
+      : null;
+    return {
+      device: simulator.udid,
+      state: simulator.state,
+      helper: remoteHelper
+        ? {
+            port: remoteHelper.port,
+            url: remoteHelper.url,
+            streamUrl: remoteHelper.streamUrl,
+            wsUrl: remoteHelper.wsUrl,
+          }
+        : null,
+    };
+  });
+}
+
 // Default per-simulator footprint when we have no running sim to measure
 // from — a fresh booted iOS sim with one app launched typically sits in
 // the 1.2–1.8 GB range. Used as a fallback only.
@@ -1563,77 +1692,158 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
       return;
     }
 
-    // Grid JSON: every supported simulator, annotated with running helper info if any.
-    if (url === base + "/grid/api") {
-      const states = await readServeSimStates();
-      const helperByUdid = new Map(states.map((s) => [s.device, s] as const));
-      const sims = await listAllSimulators();
-      // Order mirrors Xcode's Devices window: the devices the user is actually
-      // using float to the top — streaming first, then booted, then the
-      // simulator they last opened in Simulator.app — and everything else falls
-      // back to a stable family / newest-OS / name grouping. This surfaces the
-      // handful of relevant devices instead of burying them in an alphabetical
-      // wall of near-identical names. Sort on the cheap metadata BEFORE
-      // resolving the DeviceKit chrome descriptor, so pagination resolves chrome
-      // only for the page actually returned.
-      const preferredUdid = getPreferredDeviceUdid();
-      const familyRank = (name: string): number => {
-        if (/iphone/i.test(name)) return 0;
-        if (/ipad/i.test(name)) return 1;
-        if (/watch/i.test(name)) return 2;
-        if (/(apple\s*tv|^tv\b)/i.test(name)) return 3;
-        if (/vision|reality/i.test(name)) return 4;
-        return 5;
+    // Static simulator metadata. The browser keeps this catalog in memory and
+    // receives state/helper changes through the compact status feed below.
+    if (url === base + "/grid/api/catalog") {
+      const { simulators } = await readGridSnapshot(selectedDevice);
+      const total = simulators.length;
+      const { limit, offset } = parseGridPaging(rawUrl);
+      const page = limit == null ? simulators : simulators.slice(offset, offset + limit);
+      const body = JSON.stringify({
+        devices: page.map(catalogDeviceForSimulator),
+        total,
+        offset: limit == null ? 0 : offset,
+        limit: limit ?? total,
+      });
+      const etag = `"${createHash("sha1").update(body).digest("base64url")}"`;
+      if (req.headers["if-none-match"] === etag) {
+        res.writeHead(304, {
+          "Cache-Control": "private, no-cache",
+          ETag: etag,
+        });
+        res.end();
+        return;
+      }
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Cache-Control": "private, no-cache",
+        ETag: etag,
+      });
+      res.end(body);
+      return;
+    }
+
+    const computeGridStatuses = async (): Promise<string> => {
+      const { simulators, helperByUdid } = await readGridSnapshot(selectedDevice);
+      return JSON.stringify({
+        statuses: gridStatusesForRequest(
+          simulators,
+          helperByUdid,
+          req,
+          base,
+          proxyHelpers,
+        ),
+      });
+    };
+
+    // Compact point-in-time form used only while waiting for a start action.
+    if (url === base + "/grid/api/status") {
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-store",
+      });
+      res.end(await computeGridStatuses());
+      return;
+    }
+
+    // Change-only live grid state. It travels through the existing control
+    // WebSocket, so it does not consume another long-lived browser connection.
+    if (url === base + "/grid/api/status/events") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+      });
+      res.write(":\n\n");
+
+      let closed = false;
+      let computing = false;
+      let debounce: ReturnType<typeof setTimeout> | null = null;
+      let watcher: FSWatcher | null = null;
+      let watcherRetry: ReturnType<typeof setTimeout> | null = null;
+      let statusPoll: ReturnType<typeof setInterval> | null = null;
+      let heartbeat: ReturnType<typeof setInterval> | null = null;
+      req.on("close", () => {
+        closed = true;
+        if (debounce) clearTimeout(debounce);
+        if (watcherRetry) clearTimeout(watcherRetry);
+        if (statusPoll) clearInterval(statusPoll);
+        if (heartbeat) clearInterval(heartbeat);
+        watcher?.close();
+      });
+
+      let lastSent = await computeGridStatuses();
+      if (closed || res.writableEnded) return;
+      res.write("data: " + lastSent + "\n\n");
+      const sendIfChanged = async () => {
+        if (closed || computing || res.writableEnded) return;
+        computing = true;
+        try {
+          const next = await computeGridStatuses();
+          if (next === lastSent || closed || res.writableEnded) return;
+          lastSent = next;
+          res.write("data: " + next + "\n\n");
+        } finally {
+          computing = false;
+        }
       };
-      // Lower is higher in the list: streaming > selected > booted > last-opened
-      // > rest. The active `?device=` selection is ranked near the top so it's
-      // always inside the first page — otherwise a paginated client that selected
-      // a shut-down device deep in the catalog would get no chrome/placeholder
-      // for the view it's actually showing.
-      const stateRank = (d: (typeof sims)[number]) => {
-        if (helperByUdid.has(d.udid)) return 0;
-        if (selectedDevice && d.udid === selectedDevice) return 1;
-        if (d.state === "Booted") return 2;
-        if (d.udid === preferredUdid) return 3;
-        return 4;
+
+      // Filesystem notifications make helper start/stop immediate; the slow
+      // poll catches simctl changes made by Xcode or Simulator.app.
+      const onFsEvent = () => {
+        if (debounce) return;
+        debounce = setTimeout(() => {
+          debounce = null;
+          void sendIfChanged();
+        }, 150);
       };
-      // Newest runtime first, so "iPhone 17 Pro (27.0)" sorts above its 26.x twins.
-      const runtimeRank = (runtime: string): number => {
-        const m = runtime.match(/-(\d+)-(\d+)/);
-        const major = m ? Number(m[1]) : 0;
-        const minor = m ? Number(m[2]) : 0;
-        return -(major * 1000 + minor);
+      const ensureWatcher = () => {
+        if (closed || res.writableEnded || watcher || watcherRetry) return;
+        watcherRetry = setTimeout(() => {
+          watcherRetry = null;
+          if (closed || res.writableEnded || watcher) return;
+          try {
+            watcher = watch(STATE_DIR, onFsEvent);
+            watcher.on("error", () => {
+              watcher?.close();
+              watcher = null;
+              ensureWatcher();
+            });
+            void sendIfChanged();
+          } catch {
+            ensureWatcher();
+          }
+        }, 250);
       };
-      sims.sort((a, b) =>
-        stateRank(a) - stateRank(b) ||
-        familyRank(a.name) - familyRank(b.name) ||
-        a.name.localeCompare(b.name) ||
-        runtimeRank(a.runtime) - runtimeRank(b.runtime),
-      );
+      ensureWatcher();
+      statusPoll = setInterval(() => void sendIfChanged(), 3_000);
+      heartbeat = setInterval(() => {
+        if (closed || res.writableEnded) return;
+        res.write(":\n\n");
+        ensureWatcher();
+      }, 15_000);
+      return;
+    }
 
-      const total = sims.length;
+    // Grid JSON: every supported simulator, annotated with running helper info if any.
+    if (url === base + "/grid/api") {
+      const { simulators, helperByUdid } = await readGridSnapshot(selectedDevice);
+      const total = simulators.length;
       const { limit, offset } = parseGridPaging(rawUrl);
-      const page = limit == null ? sims : sims.slice(offset, offset + limit);
-      const devices = page.map((d) => {
-        const helper = helperByUdid.get(d.udid);
-        const remoteHelper = helper ? rewriteStateForRequestHost(helper, hostForRequest(req), base, httpProtocolForRequest(req), proxyHelpers) : null;
-        return {
-          device: d.udid,
-          name: d.name,
-          runtime: d.runtime,
-          state: d.state,
-          chrome: resolveDeviceKitChrome(d),
-          placeholderAsset: resolveDevicePlaceholderAsset(d),
-          helper: remoteHelper
-            ? {
-                port: remoteHelper.port,
-                url: remoteHelper.url,
-                streamUrl: remoteHelper.streamUrl,
-                wsUrl: remoteHelper.wsUrl,
-              }
-            : null,
-        };
-      });
+      const page = limit == null ? simulators : simulators.slice(offset, offset + limit);
+      const statuses = gridStatusesForRequest(
+        page,
+        helperByUdid,
+        req,
+        base,
+        proxyHelpers,
+      );
+      const devices = page.map((device, index) => ({
+        ...catalogDeviceForSimulator(device),
+        state: statuses[index]!.state,
+        helper: statuses[index]!.helper,
+      }));
       res.writeHead(200, {
         "Content-Type": "application/json",
         "Cache-Control": "no-store",
@@ -1645,7 +1855,7 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
     }
 
     // Shutdown a booted simulator. Any running helper for the device is reaped
-    // by readServeSimStates() on the next /grid/api poll (it kills helpers
+    // by readServeSimStates() on the next status sample (it kills helpers
     // whose backing simulator is no longer in the booted set).
     if (url === base + "/grid/api/shutdown" && req.method === "POST") {
       let body = "";
@@ -1664,7 +1874,7 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
         // isn't streamed here). This frees the native session immediately
         // rather than waiting for the next poll's reaper to notice.
         closeDeviceSession(udid);
-        // Drop the snapshot so the next /grid/api call re-queries simctl
+        // Drop the snapshot so the next status sample re-queries simctl
         // and prunes any helper bound to this now-shutdown device.
         bootedSnapshot = { at: 0, booted: null, names: new Map() };
         execFile("xcrun", ["simctl", "shutdown", udid], { timeout: 30_000 }, (err, _stdout, stderr) => {
@@ -2342,6 +2552,7 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
     ssePrefixes: [
       `${base}/api/events`,
       `${base}/api/event-log/events`,
+      `${base}/grid/api/status/events`,
       `${base}/appstate`,
       `${base}/logs`,
       `${base}/metrics`,