fix: support foldable simulators lent by an external device provider

packages/tool-server/src/blueprints/ax-service.ts

@@ -14,6 +14,7 @@ import {
 } from "@argent/registry";
 import { assertExternalCapability } from "../utils/external-devices";
 import { pickIosHost, type IosEndpoint } from "../utils/ios-host";
+import { socketTag } from "../utils/socket-tag";
 
 // Moved to ../utils/ax-prefs; re-exported so existing import paths keep working.
 export {
@@ -160,7 +161,7 @@ const LIVE_PANEL_TIMEOUT_MS = 2_000;
 const FILL_TIMEOUT_MS = 6_000;
 
 function getSocketPath(udid: string): string {
-  return `/tmp/ax-${udid.slice(0, 8)}.sock`;
+  return `/tmp/ax-${socketTag(udid)}.sock`;
 }
 
 interface PendingRpc {

packages/tool-server/src/blueprints/native-devtools.ts

@@ -10,6 +10,7 @@ import {
   type ServiceEvents,
 } from "@argent/registry";
 import { assertExternalCapability, externalClaimForAnyId } from "../utils/external-devices";
+import { socketTag } from "../utils/socket-tag";
 import {
   pickIosHost,
   buildDyldInsertLibraries,
@@ -502,9 +503,11 @@ interface AppConnection {
 }
 
 function getNativeDevtoolsSocketPath(udid: string): string {
-  // Deterministic and short: 28 chars, well under the 104-char macOS Unix
-  // socket limit.
-  return `/tmp/argent-nd-${udid.slice(0, 8)}.sock`;
+  /**
+   * Deterministic and short, at most 32 chars, well under the 104-char macOS
+   * Unix socket limit.
+   */
+  return `/tmp/argent-nd-${socketTag(udid)}.sock`;
 }
 
 /**

packages/tool-server/src/tools/devices/list-devices.ts

@@ -7,7 +7,7 @@ import {
   ADB_DEVICES_TIMEOUT_MS,
 } from "../../utils/adb";
 import { listRunningVvdConsolePorts } from "../../utils/vega-process";
-import { listIosSimulators, type IosSimulator } from "../../utils/ios-devices";
+import { isFoldableSimulator, listIosSimulators, type IosSimulator } from "../../utils/ios-devices";
 import { listIosPhysicalDevices } from "../../utils/ios-device/devicectl";
 import { simctlListDevices } from "../../utils/sim-remote";
 import { withRemotePrefix } from "../../utils/device-info";
@@ -72,6 +72,11 @@ type AndroidDevice = {
 type ExternalListedDevice = {
   capabilities: string[];
   external: true;
+  /**
+   * Present and true for a foldable simulator (the iPhone Duo), as on a plain
+   * iOS row.
+   */
+  foldable?: true;
   id: string;
   kind: "device" | "emulator" | "simulator";
   name: string;
@@ -233,10 +238,11 @@ export async function withDeadline<T>(p: Promise<T>, fallback: T, label: string)
   }
 }
 
-function toListedExternal(device: ExternalDevice): ExternalListedDevice {
+function toListedExternal(device: ExternalDevice, foldable: boolean): ExternalListedDevice {
   return {
     capabilities: Array.from(device.capabilities).sort(),
     external: true,
+    ...(foldable ? { foldable: true as const } : {}),
     id: device.id,
     kind: device.kind,
     name: device.name,
@@ -252,6 +258,31 @@ function toListedExternal(device: ExternalDevice): ExternalListedDevice {
   };
 }
 
+/**
+ * Whether each external device is a foldable simulator. The plain simctl row a
+ * provider's simulator shadows (its device set is in
+ * `ios.additionalDeviceSets`) already carries the verdict; otherwise it is read
+ * from the provider's device set, memoized per UDID. A foldable only differs
+ * in which panel shows the UI, so an agent needs the flag to know `fold`
+ * applies, whoever drives the device.
+ */
+async function externalFoldables(
+  external: readonly ExternalDevice[],
+  ios: readonly IosSimulator[]
+): Promise<boolean[]> {
+  const listed = new Map(ios.map((sim) => [sim.udid, sim.foldable === true]));
+
+  return Promise.all(
+    external.map(async (device) => {
+      if (device.platform !== "ios" || device.kind !== "simulator") return false;
+
+      return (
+        listed.get(device.nativeId) ?? (await isFoldableSimulator(device.id).catch(() => false))
+      );
+    })
+  );
+}
+
 /**
  * Native ids a provider is currently claiming.
  *
@@ -343,6 +374,12 @@ Booted/ready devices are listed first. Platforms whose CLI is unavailable are si
 
     const externalShadows = externalShadowIds(external);
 
+    const externalFoldable = await withDeadline(
+      externalFoldables(external, ios),
+      external.map(() => false),
+      "external-foldable"
+    );
+
     const iosTagged: IosDevice[] = ios
       .filter((simulator) => !externalShadows.has(simulator.udid))
       .map((simulator) => ({ platform: "ios", ...simulator }));
@@ -389,7 +426,7 @@ Booted/ready devices are listed first. Platforms whose CLI is unavailable are si
       ...androidDeduped,
       ...chromium,
       ...vega,
-      ...external.map(toListedExternal),
+      ...external.map((device, i) => toListedExternal(device, externalFoldable[i] === true)),
     ];
     devices.sort((a, b) => readinessRank(a) - readinessRank(b));
 

packages/tool-server/src/utils/socket-tag.ts

@@ -0,0 +1,16 @@
+import { createHash } from "node:crypto";
+
+/**
+ * The per-device part of a `/tmp/<prefix>-<tag>.sock` path.
+ *
+ * A plain UDID keeps its first 8 characters, the name these sockets have
+ * always had. Any other id (an external provider's `ext:<provider>:<udid>`)
+ * would collapse to its shared prefix that way, so every device of a provider
+ * got one socket; it gets 12 hex characters of its SHA-256 instead, which
+ * keeps the path short (macOS caps `sun_path` at 104 bytes) and can never
+ * equal an 8-character UDID tag.
+ */
+export function socketTag(deviceId: string): string {
+  if (/^[A-Za-z0-9-]+$/.test(deviceId)) return deviceId.slice(0, 8);
+  return createHash("sha256").update(deviceId).digest("hex").slice(0, 12);
+}

packages/tool-server/test/list-devices.test.ts

@@ -97,13 +97,24 @@ vi.mock("../src/utils/ios-device/devicectl", async () => {
   };
 });
 
+// Whether a provider's simulator is foldable is read from its device set when
+// the plain listing does not carry it; that read is the seam, off by default.
+vi.mock("../src/utils/ios-devices", async () => {
+  const actual = await vi.importActual<typeof import("../src/utils/ios-devices")>(
+    "../src/utils/ios-devices"
+  );
+
+  return { ...actual, isFoldableSimulator: vi.fn(async () => false) };
+});
+
 import * as fs from "node:fs";
 import * as http from "node:http";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AddressInfo } from "node:net";
 import { listDevicesTool } from "../src/tools/devices/list-devices";
 import { listIosPhysicalDevices } from "../src/utils/ios-device/devicectl";
+import { isFoldableSimulator } from "../src/utils/ios-devices";
 import {
   __resetExternalDeviceCacheForTesting,
   __resetProviderWarningsForTesting,
@@ -703,6 +714,54 @@ describe("list-devices — external provider shadows", () => {
     });
   });
 
+  it("marks a claimed foldable simulator with foldable: true", async () => {
+    /**
+     * The provider's device set is not configured, so the plain listing does
+     * not see the device and the verdict is read from the provider's set.
+     */
+    execFileMock.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === "adb" && args[0] === "devices") {
+        return { stderr: "", stdout: "List of devices attached\n" };
+      }
+
+      return { stderr: "", stdout: "" };
+    });
+
+    vi.mocked(isFoldableSimulator).mockResolvedValueOnce(true);
+
+    const result = await listDevicesTool.execute!({}, {});
+
+    const claimed = result.devices.find(
+      (device) => "udid" in device && device.udid === `ext:acme-3f2a9c:${CLAIMED_UDID}`
+    );
+
+    expect(claimed).toMatchObject({ external: true, foldable: true });
+    expect(isFoldableSimulator).toHaveBeenCalledWith(`ext:acme-3f2a9c:${CLAIMED_UDID}`);
+  });
+
+  it("leaves foldable off a claimed simulator that is not foldable", async () => {
+    execFileMock.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === "xcrun" && args[0] === "simctl") {
+        return { stderr: "", stdout: simctlJson() };
+      }
+
+      if (cmd === "adb" && args[0] === "devices") {
+        return { stderr: "", stdout: "List of devices attached\n" };
+      }
+
+      return { stderr: "", stdout: "" };
+    });
+
+    const result = await listDevicesTool.execute!({}, {});
+
+    const claimed = result.devices.find(
+      (device) => "udid" in device && device.udid === `ext:acme-3f2a9c:${CLAIMED_UDID}`
+    );
+
+    expect(claimed).toBeDefined();
+    expect(claimed).not.toHaveProperty("foldable");
+  });
+
   it("leaves an unclaimed simulator in the plain listing", async () => {
     execFileMock.mockImplementation((cmd: string, args: string[]) => {
       if (cmd === "xcrun" && args[0] === "simctl") {

packages/tool-server/test/socket-tag.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { socketTag } from "../src/utils/socket-tag";
+
+describe("socketTag", () => {
+  it("keeps the first 8 characters of a plain UDID, the existing socket name", () => {
+    expect(socketTag("0A1B2C3D-1111-2222-3333-444444444444")).toBe("0A1B2C3D");
+  });
+
+  it("gives two devices of one external provider distinct tags", () => {
+    const a = socketTag("ext:radon-1a2b3c:0A1B2C3D-1111-2222-3333-444444444444");
+    const b = socketTag("ext:radon-1a2b3c:9F8E7D6C-1111-2222-3333-444444444444");
+    expect(a).not.toBe(b);
+    expect(a).not.toBe("ext:rado");
+  });
+
+  it("is stable, short, and filename-safe for a non-UDID id", () => {
+    const id = "ext:radon-1a2b3c:0A1B2C3D-1111-2222-3333-444444444444";
+    expect(socketTag(id)).toBe(socketTag(id));
+    expect(socketTag(id)).toMatch(/^[0-9a-f]{12}$/);
+  });
+
+  it("cannot collide with a UDID tag, which is 8 characters long", () => {
+    expect(socketTag("ext:x:0A1B2C3D")).toHaveLength(12);
+  });
+});