serve-sim 0.1.35 → 0.1.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serve-sim",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "type": "module",
   "author": {
     "name": "Evan Bacon",

package/src/ax.ts

@@ -159,6 +159,7 @@ function sseMessage(payload: unknown) {
 interface AxStreamer {
   addClient(res: { write(chunk: string): void }): () => void;
   setPort(port: number): void;
+  dispose(): void;
 }
 
 function createAxStreamer({ port }: { port: number }): AxStreamer {
@@ -168,15 +169,16 @@ function createAxStreamer({ port }: { port: number }): AxStreamer {
   let pollIntervalMs = POLL_INTERVAL_MS;
   let polling = false;
   let currentPort = port;
+  let disposed = false;
 
   const schedule = () => {
-    if (clients.size === 0 || timer) return;
+    if (disposed || clients.size === 0 || timer) return;
     timer = setTimeout(poll, pollIntervalMs);
   };
 
   const poll = async () => {
     timer = null;
-    if (polling || clients.size === 0) {
+    if (disposed || polling || clients.size === 0) {
       schedule();
       return;
     }
@@ -206,7 +208,7 @@ function createAxStreamer({ port }: { port: number }): AxStreamer {
 
   return {
     setPort(nextPort: number) {
-      if (nextPort === currentPort) return;
+      if (disposed || nextPort === currentPort) return;
       currentPort = nextPort;
       latestMessage = null;
       // Avoid sitting on the unavailable-backoff interval (15s) when the
@@ -219,6 +221,7 @@ function createAxStreamer({ port }: { port: number }): AxStreamer {
       void poll();
     },
     addClient(res) {
+      if (disposed) return () => {};
       clients.add(res);
       if (latestMessage) res.write(latestMessage);
       void poll();
@@ -230,10 +233,26 @@ function createAxStreamer({ port }: { port: number }): AxStreamer {
         }
       };
     },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      clients.clear();
+      latestMessage = null;
+    },
   };
 }
 
-export function createAxStreamerCache() {
+export interface AxStreamerCache {
+  get(udid: string, port: number): AxStreamer;
+  prune(activeUdids: Iterable<string>): void;
+  size(): number;
+}
+
+export function createAxStreamerCache(): AxStreamerCache {
   const streamers = new Map<string, AxStreamer>();
 
   return {
@@ -253,5 +272,23 @@ export function createAxStreamerCache() {
       streamers.set(udid, streamer);
       return streamer;
     },
+    /**
+     * Drop streamers for simulators no longer present in `activeUdids`.
+     * Without this, the cache grew append-only across a server's lifetime
+     * as devices were booted/erased/reset, each entry holding a poll
+     * timer, last-snapshot buffer, and SSE client set.
+     */
+    prune(activeUdids) {
+      const active = activeUdids instanceof Set ? activeUdids : new Set(activeUdids);
+      for (const [udid, streamer] of streamers) {
+        if (!active.has(udid)) {
+          streamer.dispose();
+          streamers.delete(udid);
+        }
+      }
+    },
+    size() {
+      return streamers.size;
+    },
   };
 }

package/src/middleware.ts

@@ -83,6 +83,11 @@ export interface ServeSimState {
 }
 
 const axStreamerCache = createAxStreamerCache();
+
+// Hard cap on the SSE line-assembly buffer for child-process stdout.
+// A malformed log entry without a newline can't grow this beyond 1 MB;
+// the partial line is dropped rather than retained indefinitely.
+const SSE_LINE_BUFFER_LIMIT = 1024 * 1024;
 let inspectWebKitBridge: Promise<WebKitBridge> | null = null;
 
 // Known bundle IDs that are always React Native shells (used as a fallback
@@ -257,6 +262,38 @@ function endpoint(base: string, path: string, device: string): string {
   return `${value}?device=${encodeURIComponent(device)}`;
 }
 
+/**
+ * Rewrite the helper URLs in a state so they point at the hostname the request
+ * came in on. The helper binds on `*:<port>`, so once the host portion matches
+ * the dev-server origin, a remote viewer (LAN, or tunnel exposing the helper
+ * port under the same hostname) can reach the stream. Loopback callers get
+ * the state untouched.
+ */
+export function rewriteStateForRequestHost(
+  state: ServeSimState,
+  hostHeader: string | undefined,
+): ServeSimState {
+  if (!hostHeader) return state;
+  let hostname: string;
+  try {
+    hostname = new URL(`http://${hostHeader}`).hostname;
+  } catch {
+    return state;
+  }
+  // `URL.hostname` keeps brackets around IPv6 literals, so the IPv6 loopback
+  // comparison is against the bracketed form rather than `::1`.
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]") {
+    return state;
+  }
+  const rewrite = (s: string) => s.replace("127.0.0.1", hostname);
+  return {
+    ...state,
+    url: rewrite(state.url),
+    streamUrl: rewrite(state.streamUrl),
+    wsUrl: rewrite(state.wsUrl),
+  };
+}
+
 export function previewConfigForState(
   state: ServeSimState,
   base: string,
@@ -725,7 +762,8 @@ export function simMiddleware(options?: SimMiddlewareOptions) {
       }
 
       if (state) {
-        const config = JSON.stringify(previewConfigForState(state, base, serveSimBinPath(), execToken));
+        const remoteState = rewriteStateForRequestHost(state, req.headers?.host);
+        const config = JSON.stringify(previewConfigForState(remoteState, base, serveSimBinPath(), execToken));
         const configScript = `<script>window.__SIM_PREVIEW__=${config}</script>`;
         html = html.replace("<!--__SIM_PREVIEW_CONFIG__-->", configScript);
       }
@@ -755,17 +793,18 @@ export function simMiddleware(options?: SimMiddlewareOptions) {
       const sims = listAllSimulators();
       const devices = sims.map((d) => {
         const helper = helperByUdid.get(d.udid);
+        const remoteHelper = helper ? rewriteStateForRequestHost(helper, req.headers?.host) : null;
         return {
           device: d.udid,
           name: d.name,
           runtime: d.runtime,
           state: d.state,
-          helper: helper
+          helper: remoteHelper
             ? {
-                port: helper.port,
-                url: helper.url,
-                streamUrl: helper.streamUrl,
-                wsUrl: helper.wsUrl,
+                port: remoteHelper.port,
+                url: remoteHelper.url,
+                streamUrl: remoteHelper.streamUrl,
+                wsUrl: remoteHelper.wsUrl,
               }
             : null,
         };
@@ -1003,7 +1042,8 @@ export function simMiddleware(options?: SimMiddlewareOptions) {
         "Content-Type": "application/json",
         "Cache-Control": "no-store",
       });
-      res.end(JSON.stringify(state ? previewConfigForState(state, base, serveSimBinPath(), execToken) : null));
+      const remoteState = state ? rewriteStateForRequestHost(state, req.headers?.host) : null;
+      res.end(JSON.stringify(remoteState ? previewConfigForState(remoteState, base, serveSimBinPath(), execToken) : null));
       return;
     }
 
@@ -1023,6 +1063,7 @@ export function simMiddleware(options?: SimMiddlewareOptions) {
         "X-Accel-Buffering": "no",
       });
       res.write(":\n\n");
+      axStreamerCache.prune(states.map((s) => s.device));
       const ax = axStreamerCache.get(state.device, state.port);
       const removeClient = ax.addClient(res);
       req.on("close", removeClient);
@@ -1138,10 +1179,17 @@ export function simMiddleware(options?: SimMiddlewareOptions) {
           buf = buf.slice(nl + 1);
           if (line) res.write("data: " + line + "\n\n");
         }
+        // Drop a runaway partial line so a malformed/never-terminated
+        // log entry can't grow `buf` without bound.
+        if (buf.length > SSE_LINE_BUFFER_LIMIT) buf = "";
       });
 
+      child.on("error", () => { try { res.end(); } catch {} });
       child.on("close", () => res.end());
-      req.on("close", () => child.kill());
+      req.on("close", () => {
+        child.stdout?.destroy();
+        child.kill();
+      });
       return;
     }
 
@@ -1225,11 +1273,17 @@ export function simMiddleware(options?: SimMiddlewareOptions) {
           if (!event) continue;
           emitApp(event.bundleId, event.pid);
         }
+        if (buf.length > SSE_LINE_BUFFER_LIMIT) buf = "";
       });
 
+      child.on("error", () => {
+        closed = true;
+        try { res.end(); } catch {}
+      });
       child.on("close", () => res.end());
       req.on("close", () => {
         closed = true;
+        child.stdout?.destroy();
         child.kill();
       });
       return;