@expo/serve-sim 0.1.35-canary.0

package/dist/state.js

@@ -0,0 +1 @@
+import{tmpdir as O}from"os";import{join as G}from"path";import{readdirSync as P,mkdirSync as Q,writeFileSync as U,renameSync as V}from"fs";var B=G(O(),"serve-sim"),$=G(B,"server.json");function W(q){return G(B,`server-${q}.json`)}function k(q,z,C="/",H="127.0.0.1",K){let J=H==="0.0.0.0"||H==="::"?"127.0.0.1":H,M=C.replace(/^\/+/,"").replace(/\/+$/,""),N=M===""?"":`/${M}`;return{pid:process.pid,port:z,device:q,url:`http://${J}:${z}`,streamUrl:`http://${J}:${z}${N}/helper/${q}/stream.mjpeg`,wsUrl:`ws://${J}:${z}${N}/helper/${q}/ws`,...K?{streamSettings:K}:{}}}function w(q){Q(B,{recursive:!0});let z=W(q.device),C=`${z}.${process.pid}.tmp`;U(C,JSON.stringify(q,null,2),{mode:384}),V(C,z)}function L(){try{return P(B).filter((q)=>q.startsWith("server-")&&q.endsWith(".json")).map((q)=>G(B,q))}catch{return[]}}export{w as writeServeSimState,W as stateFileForDevice,L as listStateFiles,k as inProcessServeSimState,$ as STATE_FILE,B as STATE_DIR};

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@expo/serve-sim",
+  "version": "0.1.35-canary.0",
+  "type": "module",
+  "author": {
+    "name": "Evan Bacon",
+    "email": "baconbrix@gmail.com",
+    "url": "https://evanbacon.dev"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/expo/serve-sim.git",
+    "directory": "packages/serve-sim"
+  },
+  "homepage": "https://github.com/expo/serve-sim#readme",
+  "bugs": {
+    "url": "https://github.com/expo/serve-sim/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "bin": {
+    "serve-sim": "dist/serve-sim.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "cpu": [
+    "arm64"
+  ],
+  "files": [
+    "LICENSE",
+    "dist/serve-sim.js",
+    "dist/middleware.js",
+    "dist/middleware.cjs",
+    "dist/state.js",
+    "dist/simcam/libSimCameraInjector.dylib",
+    "dist/simcam/serve-sim-camera-helper",
+    "dist/simax/serve-sim-ax-settings",
+    "src/ax-shared.ts",
+    "src/ax.ts",
+    "src/camera-helper.ts",
+    "src/connect-to-fetch.ts",
+    "src/middleware.ts",
+    "src/native.ts",
+    "src/state.ts",
+    "src/stream-settings.ts",
+    "Sources/SimCameraInjector/SimCameraInjector.m",
+    "Sources/SimCameraInjector/SimCam*.h",
+    "Sources/SimCameraInjector/SimCam*.m",
+    "Sources/SimCameraInjector/include/SimCamShared.h",
+    "Sources/SimCameraInjector/build.sh",
+    "Sources/SimCameraHelper/main.m",
+    "Sources/SimCameraHelper/build.sh",
+    "Sources/SimAXSettings/sim-ax-settings.m",
+    "Sources/SimAXSettings/build.sh",
+    "dist/native/serve-sim-native.node",
+    "dist/bin/LiveKitWebRTC.framework"
+  ],
+  "exports": {
+    "./middleware": {
+      "require": "./dist/middleware.cjs",
+      "import": "./dist/middleware.js",
+      "types": "./src/middleware.ts"
+    },
+    "./state": {
+      "import": "./dist/state.js",
+      "types": "./src/state.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run build.ts",
+    "dev": "bun run dev.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/debug": "^4.1.13",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@types/ws": "^8.18.1",
+    "bun-plugin-tailwind": "^0.1.2",
+    "commander": "^14.0.1",
+    "debug": "^4.4.3",
+    "lucide-react": "^1.20.0",
+    "node-swift": "1.5.1",
+    "preact": "^10.29.1",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tailwindcss": "^4.1.7",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "inspect-webkit": "^0.0.5",
+    "sonner": "^2.0.7",
+    "ws": "^8.21.0"
+  }
+}

package/src/ax-shared.ts

@@ -0,0 +1,25 @@
+export const AX_UNAVAILABLE_ERROR = "Accessibility unavailable on this simulator.";
+
+export interface AxRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface AxElement {
+  id: string;
+  path: string;
+  label: string;
+  value: string;
+  role: string;
+  type: string;
+  enabled: boolean;
+  frame: AxRect;
+}
+
+export interface AxSnapshot {
+  screen: { width: number; height: number };
+  elements: AxElement[];
+  errors?: string[];
+}

package/src/ax.ts

@@ -0,0 +1,258 @@
+import { AX_UNAVAILABLE_ERROR } from "./ax-shared";
+import type { AxElement, AxRect, AxSnapshot } from "./ax-shared";
+import { axDescribeAsync } from "./native";
+
+export type { AxElement, AxRect, AxSnapshot } from "./ax-shared";
+
+const MAX_ELEMENTS = 500;
+const POLL_INTERVAL_MS = 500;
+const MAX_POLL_INTERVAL_MS = 2000;
+const UNAVAILABLE_RETRY_INTERVAL_MS = 15_000;
+
+interface RawAxeNode {
+  AXUniqueId: string | null;
+  AXLabel: string | null;
+  AXValue: string | null;
+  enabled: boolean;
+  frame: AxRect;
+  role_description: string;
+  type: string;
+  children: RawAxeNode[];
+}
+
+function chooseScreenFrame(roots: RawAxeNode[]) {
+  return roots[0]?.frame ?? {
+    x: 0,
+    y: 0,
+    width: 1,
+    height: 1,
+  };
+}
+
+function sameRect(a: AxRect, b: AxRect) {
+  return (
+    Math.abs(a.x - b.x) < 0.5 &&
+    Math.abs(a.y - b.y) < 0.5 &&
+    Math.abs(a.width - b.width) < 0.5 &&
+    Math.abs(a.height - b.height) < 0.5
+  );
+}
+
+function normalizeAxTree(roots: RawAxeNode[]): AxSnapshot {
+  const screen = chooseScreenFrame(roots);
+  const elements: AxElement[] = [];
+
+  const visit = (node: RawAxeNode, path: string) => {
+    if (elements.length >= MAX_ELEMENTS) return;
+
+    const frame = node.frame;
+    const isScreenSized = sameRect(frame, screen);
+
+    if (!isScreenSized) {
+      elements.push({
+        id: node.AXUniqueId ?? path,
+        path,
+        label: node.AXLabel ?? "",
+        value: node.AXValue ?? "",
+        role: node.role_description,
+        type: node.type,
+        enabled: node.enabled !== false,
+        frame,
+      });
+    }
+
+    for (let index = 0; index < node.children.length && elements.length < MAX_ELEMENTS; index++) {
+      visit(node.children[index]!, `${path}.${index}`);
+    }
+  };
+
+  for (let index = 0; index < roots.length && elements.length < MAX_ELEMENTS; index++) {
+    visit(roots[index]!, String(index));
+  }
+
+  return {
+    screen: {
+      width: screen.width,
+      height: screen.height,
+    },
+    elements,
+  };
+}
+
+async function snapshotFromNative(udid: string): Promise<AxSnapshot> {
+  let raw: RawAxeNode[];
+  try {
+    raw = JSON.parse(await axDescribeAsync(udid)) as RawAxeNode[];
+  } catch {
+    // The in-process AX bridge throws when the simulator can't satisfy
+    // accessibility right now (framework missing, SpringBoard restarting,
+    // etc). Surface as the standard "unavailable" error so the streamer backs
+    // off and recovers automatically.
+    return {
+      screen: { width: 1, height: 1 },
+      elements: [],
+      errors: [AX_UNAVAILABLE_ERROR],
+    };
+  }
+  return normalizeAxTree(raw);
+}
+
+function isAxUnavailableSnapshot(snapshot: AxSnapshot | null) {
+  return snapshot?.errors?.includes(AX_UNAVAILABLE_ERROR) ?? false;
+}
+
+function isUsableAxSnapshot(snapshot: AxSnapshot) {
+  return (
+    snapshot.elements.length > 0 &&
+    snapshot.screen.width > 1 &&
+    snapshot.screen.height > 1
+  );
+}
+
+async function collectAxSnapshot(udid: string): Promise<AxSnapshot> {
+  const errors: string[] = [];
+
+  try {
+    const snapshot = await snapshotFromNative(udid);
+    if (snapshot.errors?.length) return snapshot;
+    if (!isUsableAxSnapshot(snapshot)) {
+      throw new Error(
+        `native AX returned ${snapshot.elements.length} elements in ${snapshot.screen.width}x${snapshot.screen.height} AX space`,
+      );
+    }
+    return {
+      ...snapshot,
+      errors,
+    };
+  } catch (error) {
+    errors.push((error as Error).message || String(error));
+  }
+
+  return {
+    screen: { width: 1, height: 1 },
+    elements: [],
+    errors,
+  };
+}
+
+function sseMessage(payload: unknown) {
+  return `data: ${JSON.stringify(payload)}\n\n`;
+}
+
+interface AxStreamer {
+  addClient(res: { write(chunk: string): void }): () => void;
+  dispose(): void;
+}
+
+function createAxStreamer({ udid }: { udid: string }): AxStreamer {
+  const clients = new Set<{ write(chunk: string): void }>();
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let latestMessage: string | null = null;
+  let pollIntervalMs = POLL_INTERVAL_MS;
+  let polling = false;
+  let disposed = false;
+
+  const schedule = () => {
+    if (disposed || clients.size === 0 || timer) return;
+    timer = setTimeout(poll, pollIntervalMs);
+  };
+
+  const poll = async () => {
+    timer = null;
+    if (disposed || polling || clients.size === 0) {
+      schedule();
+      return;
+    }
+
+    polling = true;
+    try {
+      const next = await collectAxSnapshot(udid);
+      const nextMessage = sseMessage(next);
+      if (nextMessage !== latestMessage) {
+        for (const client of clients) client.write(nextMessage);
+        pollIntervalMs = POLL_INTERVAL_MS;
+      } else {
+        pollIntervalMs = Math.min(pollIntervalMs * 2, MAX_POLL_INTERVAL_MS);
+      }
+      latestMessage = nextMessage;
+      // If the helper says AX is unavailable (framework missing, sim
+      // booting), keep polling but back off so we recover automatically
+      // without spamming requests.
+      if (isAxUnavailableSnapshot(next)) {
+        pollIntervalMs = UNAVAILABLE_RETRY_INTERVAL_MS;
+      }
+    } finally {
+      polling = false;
+      schedule();
+    }
+  };
+
+  return {
+    addClient(res) {
+      if (disposed) return () => {};
+      clients.add(res);
+      if (latestMessage) res.write(latestMessage);
+      void poll();
+      return () => {
+        clients.delete(res);
+        if (clients.size === 0 && timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      clients.clear();
+      latestMessage = null;
+    },
+  };
+}
+
+export interface AxStreamerCache {
+  get(udid: string): AxStreamer;
+  prune(activeUdids: Iterable<string>): void;
+  size(): number;
+}
+
+export function createAxStreamerCache(): AxStreamerCache {
+  const streamers = new Map<string, AxStreamer>();
+
+  return {
+    /**
+     * Get (or create) the accessibility-snapshot streamer for a simulator.
+     * Snapshots come from the in-process native AX bridge keyed by udid.
+     */
+    get(udid: string) {
+      const existing = streamers.get(udid);
+      if (existing) return existing;
+
+      const streamer = createAxStreamer({ udid });
+      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/camera-helper.ts

@@ -0,0 +1,150 @@
+import { createHash } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { STATE_DIR } from "./state";
+
+export const CAMERA_STATE_DIR = join(STATE_DIR, "simcam");
+const HELPER_TIMEOUT_MS = 3000;
+
+interface InjectedBundlesState {
+  helperPid: number;
+  bundleIds: string[];
+}
+
+export interface CameraHelperReply {
+  [key: string]: unknown;
+  ok?: boolean;
+  source?: string;
+  arg?: string;
+  mirror?: string;
+  error?: string;
+}
+
+export interface CameraStatusReply extends CameraHelperReply {
+  udid: string;
+  alive: boolean;
+  helperPid?: number | null;
+  bundleIds?: string[];
+}
+
+export function cameraHelperPidFile(udid: string): string {
+  return join(CAMERA_STATE_DIR, `${udid}.pid`);
+}
+
+export function cameraHelperBundlesFile(udid: string): string {
+  return join(CAMERA_STATE_DIR, `${udid}.bundles.json`);
+}
+
+export function cameraHelperSocketFile(udid: string): string {
+  // POSIX sun_path is 104 chars on macOS, so keep this short.
+  const short = createHash("sha1").update(udid).digest("hex").slice(0, 12);
+  return `/tmp/serve-sim-cam-${short}.sock`;
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readCameraHelperPid(udid: string): number | null {
+  try {
+    const pid = Number(readFileSync(cameraHelperPidFile(udid), "utf-8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function parseCameraHelperReply(value: unknown): CameraHelperReply {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("invalid camera helper reply");
+  }
+  return value as CameraHelperReply;
+}
+
+export async function sendCameraHelperCommand(
+  udid: string,
+  command: object,
+): Promise<CameraHelperReply> {
+  const socketPath = cameraHelperSocketFile(udid);
+  if (!existsSync(socketPath)) throw new Error("camera helper socket not found");
+  const net = await import("net");
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    socket.setEncoding("utf8");
+    let buffer = "";
+    let settled = false;
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+
+    const settle = (error?: unknown, reply?: CameraHelperReply) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      if (error) reject(error);
+      else resolve(reply ?? {});
+    };
+
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newline = buffer.indexOf("\n");
+      if (newline < 0) return;
+      try {
+        settle(undefined, parseCameraHelperReply(JSON.parse(buffer.slice(0, newline)) as unknown));
+      } catch (error) {
+        settle(error);
+      }
+      socket.end();
+    });
+    socket.on("error", settle);
+    socket.on("close", () => settle(new Error("socket closed")));
+    timeout = setTimeout(() => {
+      socket.destroy();
+      settle(new Error("helper timeout"));
+    }, HELPER_TIMEOUT_MS);
+    socket.write(JSON.stringify(command) + "\n");
+  });
+}
+
+export function isCameraHelperAlive(udid: string): boolean {
+  const pid = readCameraHelperPid(udid);
+  return pid !== null && isProcessAlive(pid) && existsSync(cameraHelperSocketFile(udid));
+}
+
+export function readInjectedCameraBundles(udid: string): string[] {
+  let state: InjectedBundlesState;
+  try {
+    const value = JSON.parse(readFileSync(cameraHelperBundlesFile(udid), "utf-8")) as unknown;
+    if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+    const candidate = value as Partial<InjectedBundlesState>;
+    if (typeof candidate.helperPid !== "number" || !Array.isArray(candidate.bundleIds)) return [];
+    state = { helperPid: candidate.helperPid, bundleIds: candidate.bundleIds };
+  } catch {
+    return [];
+  }
+  const currentHelperPid = readCameraHelperPid(udid);
+  if (currentHelperPid === null || state.helperPid !== currentHelperPid) return [];
+  return state.bundleIds.filter((bundleId): bundleId is string => typeof bundleId === "string");
+}
+
+export async function readCameraStatus(udid: string): Promise<CameraStatusReply> {
+  if (!isCameraHelperAlive(udid)) return { udid, alive: false };
+
+  const helperPid = readCameraHelperPid(udid);
+  const bundleIds = readInjectedCameraBundles(udid);
+  try {
+    const reply = await sendCameraHelperCommand(udid, { action: "status" });
+    return { ...reply, udid, alive: true, helperPid, bundleIds };
+  } catch (error) {
+    return {
+      udid,
+      alive: true,
+      helperPid,
+      bundleIds,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}