@houwert/conductor 0.32.1 → 0.33.1

package/dist/commands/fold.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.getFold = getFold;
+exports.setFold = setFold;
+exports.HELP = `  get-fold                             Print the hinge angle of a foldable device (iPhone Duo)
+  set-fold <closed|book|open|0-180>    Fold, half-open, unfold, or set an exact hinge angle`;
+const runner_js_1 = require("../runner.js");
+const session_js_1 = require("../session.js");
+const output_js_1 = require("../output.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const ios_fold_js_1 = require("../drivers/ios-fold.js");
+async function resolveDeviceId(sessionName) {
+    if (sessionName !== 'default')
+        return sessionName;
+    const session = await (0, session_js_1.getSession)(sessionName);
+    return session.deviceId ?? (await (0, runner_js_1.detectFirstDevice)());
+}
+/** Fold control talks to the device directly, so no test driver is needed. */
+async function foldableDeviceId(sessionName, opts) {
+    const deviceId = await resolveDeviceId(sessionName);
+    if (!deviceId) {
+        (0, output_js_1.printError)('No device found. Connect a device or start a simulator first.', opts);
+        return null;
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    if (platform !== 'ios') {
+        (0, output_js_1.printError)(`fold control is iOS-only — foldable simulators such as the iPhone Duo`, opts);
+        return null;
+    }
+    return deviceId;
+}
+async function getFold(opts = {}, sessionName = 'default') {
+    const deviceId = await foldableDeviceId(sessionName, opts);
+    if (!deviceId)
+        return 1;
+    try {
+        const state = await (0, ios_fold_js_1.getFoldState)(deviceId);
+        if (opts.json)
+            (0, output_js_1.printData)(state, opts);
+        else
+            (0, output_js_1.printSuccess)(`fold: ${state.pose} (${state.angle}°)`, opts);
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`get-fold — failed\n${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}
+async function setFold(value, opts = {}, sessionName = 'default') {
+    const key = value.trim().toLowerCase();
+    const angle = (0, ios_fold_js_1.resolveFoldAngle)(value);
+    if (angle === null) {
+        (0, output_js_1.printError)(`set-fold must be one of: ${Object.keys(ios_fold_js_1.FOLD_POSES).join(', ')}, or an angle from 0 to 180`, opts);
+        return 1;
+    }
+    const deviceId = await foldableDeviceId(sessionName, opts);
+    if (!deviceId)
+        return 1;
+    try {
+        await (0, ios_fold_js_1.setFoldAngle)(deviceId, angle);
+        (0, output_js_1.printSuccess)(`set-fold ${key in ios_fold_js_1.FOLD_POSES ? key : angle} (${angle}°) — done`, opts);
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`set-fold ${value} — failed\n${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}

package/dist/commands/get-orientation.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.getOrientation = getOrientation;
+exports.HELP = `  get-orientation                      Print the device's current orientation`;
+const runner_js_1 = require("../runner.js");
+const session_js_1 = require("../session.js");
+const output_js_1 = require("../output.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const devicectl_js_1 = require("../drivers/devicectl.js");
+async function resolveDeviceId(sessionName) {
+    if (sessionName !== 'default')
+        return sessionName;
+    const session = await (0, session_js_1.getSession)(sessionName);
+    return session.deviceId ?? (await (0, runner_js_1.detectFirstDevice)());
+}
+async function getOrientation(opts = {}, sessionName = 'default') {
+    const deviceId = await resolveDeviceId(sessionName);
+    if (!deviceId) {
+        (0, output_js_1.printError)('No device found. Connect a device or start a simulator first.', opts);
+        return 1;
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    if (platform !== 'ios') {
+        (0, output_js_1.printError)('get-orientation is iOS-only (simulators and physical devices)', opts);
+        return 1;
+    }
+    try {
+        const orientation = await (0, devicectl_js_1.getOrientation)(deviceId);
+        if (opts.json)
+            (0, output_js_1.printData)({ orientation }, opts);
+        else
+            (0, output_js_1.printSuccess)(`orientation: ${orientation}`, opts);
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`get-orientation — failed\n${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}

package/dist/commands/screenshot.js

@@ -5,8 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.screenshot = screenshot;
-exports.HELP = `  take-screenshot [<element>] [--output <path>] [--full-page]
+exports.HELP = `  take-screenshot [<element>] [--output <path>] [--full-page] [--display <panel>]
                                        Take screenshot (--full-page: web only, capture entire scrollable page)
+    --display <cover|inner|id>        Which display to capture (default: whichever panel
+                                       is live). An unknown value lists the device's displays
     <element>                         Crop to the element matched by text (positional)
     --id <id>                         Crop to the element matched by accessibility id
     --text <text>                     Crop to the element matched by text only (not id)
@@ -21,9 +23,14 @@ exports.HELP = `  take-screenshot [<element>] [--output <path>] [--full-page]
     --left-of <text>                  Match element left of the given reference
     --right-of <text>                 Match element right of the given reference`;
 const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
 const promises_1 = __importDefault(require("fs/promises"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
 const runner_js_1 = require("../runner.js");
 const output_js_1 = require("../output.js");
+const devicectl_js_1 = require("../drivers/devicectl.js");
+const ios_displays_js_1 = require("../drivers/ios-displays.js");
 const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
 const web_js_1 = require("../drivers/web.js");
@@ -33,6 +40,51 @@ const wait_js_1 = require("../drivers/wait.js");
 const direct_ios_selector_js_1 = require("../drivers/direct-ios-selector.js");
 const png_crop_js_1 = require("../png-crop.js");
 const DEFAULT_MARGIN_PX = 8;
+const exec = (0, util_1.promisify)(child_process_1.execFile);
+/**
+ * Grab the screen, pointing at the right panel on a multi-display device.
+ *
+ * The driver always screenshots `XCUIScreen.main`, which on a foldable is the
+ * cover panel — powered off, and so a black image, whenever the device is
+ * unfolded. When the device reports more than one integrated panel we capture
+ * the live one through simctl instead. Ordinary devices keep the driver path.
+ */
+async function captureScreen(driver, opts, displayOverride) {
+    const deviceId = driver instanceof ios_js_1.IOSDriver ? driver.deviceId : undefined;
+    if (!deviceId || (!displayOverride && !(driver instanceof ios_js_1.IOSDriver))) {
+        return await driver.screenshot(opts);
+    }
+    const displays = await (0, devicectl_js_1.listDisplays)(deviceId).catch(() => []);
+    if (!displays.length) {
+        if (displayOverride)
+            throw new Error("could not read this device's displays");
+        return await driver.screenshot(opts);
+    }
+    const choice = (0, ios_displays_js_1.pickCaptureDisplay)(displays, displayOverride);
+    if (choice.error)
+        throw new Error(choice.error);
+    const primary = displays.find((d) => d.primary);
+    // Nothing to redirect: the driver already captures the primary panel.
+    if (choice.displayId === null || (primary && choice.displayId === primary.displayId)) {
+        return await driver.screenshot(opts);
+    }
+    const file = path_1.default.join(os_1.default.tmpdir(), `conductor-shot-${Date.now()}.png`);
+    try {
+        await exec('xcrun', [
+            'simctl',
+            'io',
+            deviceId,
+            'screenshot',
+            '--display',
+            String(choice.displayId),
+            file,
+        ]);
+        return await promises_1.default.readFile(file);
+    }
+    finally {
+        await promises_1.default.unlink(file).catch(() => { });
+    }
+}
 async function screenshot(outputPath, opts = {}, sessionName = 'default', fullPage = false, query = '', flags = {}) {
     const timestamp = Date.now();
     const defaultName = `screenshot-${timestamp}.png`;
@@ -63,7 +115,7 @@ async function screenshot(outputPath, opts = {}, sessionName = 'default', fullPa
                 : '';
     const margin = flags.margin ?? DEFAULT_MARGIN_PX;
     const result = await (0, runner_js_1.runDirect)(async (driver) => {
-        const buf = await driver.screenshot({ fullPage });
+        const buf = await captureScreen(driver, { fullPage }, flags.display);
         let out = buf;
         if (sel) {
             let el;

package/dist/commands/set-orientation.js

@@ -2,24 +2,73 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.setOrientation = setOrientation;
-exports.HELP = `  set-orientation <portrait|landscape> Set device orientation`;
+exports.HELP = `  set-orientation <orientation>        Set device orientation
+                                       portrait | landscape (all platforms)
+                                       portraitUpsideDown | landscapeLeft | landscapeRight |
+                                       faceUp | faceDown (iOS only)`;
 const runner_js_1 = require("../runner.js");
+const session_js_1 = require("../session.js");
 const output_js_1 = require("../output.js");
-const VALID = ['portrait', 'landscape'];
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const devicectl_js_1 = require("../drivers/devicectl.js");
+const ios_fold_js_1 = require("../drivers/ios-fold.js");
+/** Accepted everywhere; other platforms handle these through their driver. */
+const BASIC = {
+    portrait: 'portrait',
+    landscape: 'landscapeLeft',
+};
+/** iOS-only orientations, which the test driver has no concept of. */
+const IOS_ONLY = {
+    portraitupsidedown: 'portraitUpsideDown',
+    landscapeleft: 'landscapeLeft',
+    landscaperight: 'landscapeRight',
+    faceup: 'faceUp',
+    facedown: 'faceDown',
+};
 async function setOrientation(orientation, opts = {}, sessionName = 'default') {
-    if (!VALID.includes(orientation.toLowerCase())) {
-        (0, output_js_1.printError)(`set-orientation must be one of: ${VALID.join(', ')}`, opts);
+    const key = orientation.toLowerCase();
+    const iosValue = BASIC[key] ?? IOS_ONLY[key];
+    if (!iosValue) {
+        (0, output_js_1.printError)(`set-orientation must be one of: ${[...Object.keys(BASIC), ...Object.values(IOS_ONLY)].join(', ')}`, opts);
+        return 1;
+    }
+    const deviceId = sessionName !== 'default'
+        ? sessionName
+        : ((await (0, session_js_1.getSession)(sessionName)).deviceId ?? (await (0, runner_js_1.detectFirstDevice)()));
+    if (!deviceId) {
+        (0, output_js_1.printError)('No device found. Connect a device or start a simulator first.', opts);
+        return 1;
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    // On iOS everything goes through devicectl: it covers the full set and needs
+    // no test driver running. Other platforms keep using their driver.
+    if (platform === 'ios') {
+        try {
+            await (0, devicectl_js_1.setOrientation)(deviceId, iosValue);
+            // Foldables accept the call and ignore it — their pose machine owns
+            // orientation — so confirm, and rotate through the relay if it didn't take.
+            if ((await (0, devicectl_js_1.getOrientation)(deviceId).catch(() => null)) !== iosValue) {
+                await (0, ios_fold_js_1.setOrientationViaRelay)(deviceId, iosValue);
+            }
+            (0, output_js_1.printSuccess)(`set-orientation ${iosValue} — done`, opts);
+            return 0;
+        }
+        catch (err) {
+            (0, output_js_1.printError)(`set-orientation ${orientation} — failed\n${err instanceof Error ? err.message : String(err)}`, opts);
+            return 1;
+        }
+    }
+    if (!BASIC[key]) {
+        (0, output_js_1.printError)(`${iosValue} is iOS-only — use portrait or landscape on this platform`, opts);
         return 1;
     }
     const result = await (0, runner_js_1.runDirect)(async (driver) => {
-        await driver.setOrientation(orientation.toLowerCase());
+        await driver.setOrientation(key);
     }, sessionName);
     if (result.success) {
-        (0, output_js_1.printSuccess)(`set-orientation ${orientation} — done`, opts);
+        (0, output_js_1.printSuccess)(`set-orientation ${key} — done`, opts);
         return 0;
     }
-    else {
-        (0, output_js_1.printError)(`set-orientation ${orientation} — failed\n${result.stderr}`, opts);
-        return 1;
-    }
+    (0, output_js_1.printError)(`set-orientation ${orientation} — failed\n${result.stderr}`, opts);
+    return 1;
 }

package/dist/drivers/bootstrap.js

@@ -11,6 +11,7 @@ exports.getInputPort = getInputPort;
 exports.getStreamPort = getStreamPort;
 exports.getInprocDylibPath = getInprocDylibPath;
 exports.getHidBinaryPath = getHidBinaryPath;
+exports.getFoldDylibPath = getFoldDylibPath;
 exports.getCaptureBinaryPath = getCaptureBinaryPath;
 exports.installDriver = installDriver;
 exports.isSimulatorBooted = isSimulatorBooted;
@@ -363,6 +364,18 @@ async function getHidBinaryPath() {
     const p = path_1.default.join(dir, 'ios-hid', 'conductor-hid');
     return fs_1.default.existsSync(p) ? p : null;
 }
+/**
+ * Absolute path to the fold controller dylib (`ios-fold/conductor-fold.dylib`),
+ * built by `packages/ios-fold/tools/build-fold.sh`. Injected into a foldable
+ * simulator's locationd to drive the hinge. Returns null if it hasn't been built.
+ */
+async function getFoldDylibPath() {
+    const dir = await getDriversDir().catch(() => null);
+    if (!dir)
+        return null;
+    const p = path_1.default.join(dir, 'ios-fold', 'conductor-fold.dylib');
+    return fs_1.default.existsSync(p) ? p : null;
+}
 /**
  * Absolute path to the host-side Simulator video capture binary
  * (`ios-capture/conductor-capture`), built by

package/dist/drivers/devicectl.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEVICECTL_ORIENTATIONS = void 0;
 exports.parseDevicectlDevices = parseDevicectlDevices;
 exports.listPhysicalDevices = listPhysicalDevices;
 exports.findPhysicalDevice = findPhysicalDevice;
@@ -14,6 +15,9 @@ exports.uninstallApp = uninstallApp;
 exports.launchApp = launchApp;
 exports.terminateApp = terminateApp;
 exports.listApps = listApps;
+exports.getOrientation = getOrientation;
+exports.setOrientation = setOrientation;
+exports.listDisplays = listDisplays;
 /**
  * `xcrun devicectl` wrapper — the physical-device counterpart to `simctl`.
  *
@@ -241,3 +245,51 @@ async function listApps(deviceId) {
         name: a.name ?? a.bundleIdentifier,
     }));
 }
+/** Orientations devicectl accepts; a superset of the driver's portrait/landscape. */
+exports.DEVICECTL_ORIENTATIONS = [
+    'portrait',
+    'portraitUpsideDown',
+    'landscapeLeft',
+    'landscapeRight',
+    'faceUp',
+    'faceDown',
+];
+/**
+ * Read the device's current orientation. Works for simulators as well as
+ * physical devices — CoreDevice covers both — and needs no running test driver.
+ */
+async function getOrientation(deviceId) {
+    const out = await devicectl(['device', 'orientation', 'get', '--device', deviceId]);
+    // Devices that track flat poses report "Non-flat Orientation" instead.
+    const match = out.match(/Current Device (?:Non-flat )?Orientation:\s*(\w+)/);
+    if (!match)
+        throw new Error(`could not parse orientation from devicectl: ${out.trim()}`);
+    return match[1];
+}
+/** Set the device's orientation. */
+async function setOrientation(deviceId, orientation) {
+    await devicectl(['device', 'orientation', 'set', '--device', deviceId, orientation]);
+}
+/**
+ * List the device's displays. Foldables report two integrated panels and flag
+ * which one is live, which is the only reliable way to know where to point a
+ * screenshot: the swap follows the system's own transition logic, not the
+ * hinge angle.
+ */
+async function listDisplays(deviceId) {
+    const parsed = await devicectlJson(['device', 'info', 'displays', '--device', deviceId], 15000);
+    return (parsed.result?.displays ?? [])
+        .filter((d) => typeof d.displayId === 'number')
+        .map((d) => {
+        // `type` is a single-key object, e.g. { integrated: {} } or { carPlay: {} }.
+        const kind = Object.keys(d.type ?? {})[0] ?? '';
+        return {
+            displayId: d.displayId,
+            name: d.name ?? '',
+            active: d.active === true,
+            primary: d.primary === true,
+            kind,
+            integrated: kind === 'integrated',
+        };
+    });
+}

package/dist/drivers/ios-displays.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickCaptureDisplay = pickCaptureDisplay;
+/**
+ * Roles, which mean the same thing on any platform that grows a foldable.
+ * Everything else is addressed by display id: a device's own class and panel
+ * names (integrated/carPlay, LCD-1) are platform vocabulary that wouldn't carry
+ * over to Android, and every display it could name already has an id. Unknown
+ * values list the device's displays so the ids are discoverable.
+ */
+const ROLE_ALIASES = {
+    cover: 'primary',
+    main: 'primary',
+    primary: 'primary',
+    inner: 'secondary',
+    secondary: 'secondary',
+};
+/**
+ * Pick the display to capture. With no override this is whichever panel is
+ * live, which keeps screenshots working across a fold without the caller
+ * having to think about it. Returns null for ordinary single-display devices
+ * so they keep using the driver path untouched.
+ */
+function pickCaptureDisplay(displays, override) {
+    const integrated = displays.filter((d) => d.integrated);
+    if (override) {
+        const key = override.trim().toLowerCase();
+        const id = Number(key);
+        if (Number.isInteger(id) && displays.some((d) => d.displayId === id)) {
+            return { displayId: id };
+        }
+        const role = ROLE_ALIASES[key];
+        if (role) {
+            const match = role === 'primary' ? integrated.find((d) => d.primary) : integrated.find((d) => !d.primary);
+            if (match)
+                return { displayId: match.displayId };
+        }
+        const known = displays
+            .map((d) => `${d.displayId} (${[d.name, d.kind].filter(Boolean).join(', ')})`)
+            .join('; ');
+        return {
+            displayId: null,
+            error: `this device has no '${override}' display — it reports: ${known}`,
+        };
+    }
+    // Single-panel devices: nothing to choose, let the driver handle it.
+    if (integrated.length < 2)
+        return { displayId: null };
+    const live = integrated.find((d) => d.active) ?? integrated.find((d) => d.primary);
+    return { displayId: live ? live.displayId : null };
+}

package/dist/drivers/ios-fold.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RELAY_ORIENTATIONS = exports.FOLD_POSES = void 0;
+exports.resolveFoldAngle = resolveFoldAngle;
+exports.poseForAngle = poseForAngle;
+exports.ensureFoldControllerInjected = ensureFoldControllerInjected;
+exports.setFoldAngle = setFoldAngle;
+exports.setOrientationViaRelay = setOrientationViaRelay;
+exports.getFoldState = getFoldState;
+/**
+ * Fold (hinge) control for foldable simulators, e.g. the iPhone Duo.
+ *
+ * Apple exposes no setter: `simctl` has nothing, and `devicectl` only *reads*
+ * the angle. The fold is driven by an AVP event that travels Device Hub ->
+ * CoreDevice remote HID -> the guest's dtuhidd -> locationd, whose CoreMotion
+ * relay synthesises the hinge HID event SpringBoard folds on. Conductor's own
+ * Indigo channel cannot carry it (backboardd rejects hinge events), so we
+ * inject `drivers/ios-fold/conductor-fold.dylib` into the simulator's locationd
+ * and feed that relay directly — see packages/ios-fold for the full rationale.
+ *
+ * Injection lasts until locationd restarts, so every call re-checks the pid the
+ * dylib recorded and re-injects when it no longer matches.
+ */
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const bootstrap_js_1 = require("./bootstrap.js");
+const exec = (0, util_1.promisify)(child_process_1.execFile);
+/** Named poses, mirroring Device Hub's three hinge buttons. */
+exports.FOLD_POSES = {
+    closed: 0,
+    book: 130,
+    open: 180,
+};
+/** A simulator process's /tmp is the host's /tmp, so scope paths by device. */
+const controlPath = (udid) => `/tmp/conductor-fold-${udid}`;
+const orientationPath = (udid) => `/tmp/conductor-orientation-${udid}`;
+/**
+ * The relay's own orientation vocabulary, which is not devicectl's spelling.
+ * Foldables ignore `devicectl device orientation set`, so they need this path.
+ */
+exports.RELAY_ORIENTATIONS = {
+    portrait: 'portrait',
+    portraitUpsideDown: 'pud',
+    landscapeLeft: 'landscape-left',
+    landscapeRight: 'landscape-right',
+    faceUp: 'faceup',
+    faceDown: 'facedown',
+};
+/**
+ * Resolve a CLI value — a pose name or an angle in degrees — to an angle.
+ * Returns null for anything else, including an empty value: `Number('')` is 0,
+ * which would otherwise turn a bare `set-fold` into "fold the device shut".
+ */
+function resolveFoldAngle(value) {
+    const key = value.trim().toLowerCase();
+    if (!key)
+        return null;
+    if (key in exports.FOLD_POSES)
+        return exports.FOLD_POSES[key];
+    const angle = Number(key);
+    if (!Number.isFinite(angle) || angle < 0 || angle > 180)
+        return null;
+    return angle;
+}
+/**
+ * Name the pose when the angle is close to one, else call it partial. Which
+ * panel is lit is deliberately not derived from the angle: the system swaps
+ * displays on its own transition logic, so a hinge parked mid-way can still be
+ * driving the cover display.
+ */
+function poseForAngle(angle) {
+    for (const [name, value] of Object.entries(exports.FOLD_POSES)) {
+        if (Math.abs(value - angle) <= 10)
+            return name;
+    }
+    return 'partial';
+}
+async function locationdPid(udid) {
+    try {
+        const { stdout } = await exec('xcrun', [
+            'simctl',
+            'spawn',
+            udid,
+            'launchctl',
+            'print',
+            'system/com.apple.locationd',
+        ]);
+        return stdout.match(/^\s*pid = (\d+)/m)?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function recordedPid(udid) {
+    try {
+        return fs_1.default.readFileSync(`${controlPath(udid)}.pid`, 'utf8').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Ensure the fold controller is live inside locationd. DYLD_INSERT_LIBRARIES is
+ * set on the simulator's launchd only for the moment it takes to restart
+ * locationd — anything else launched in that window loads the dylib too, which
+ * is harmless (it no-ops outside locationd).
+ */
+async function ensureFoldControllerInjected(udid) {
+    const pid = await locationdPid(udid);
+    if (pid && pid === recordedPid(udid))
+        return;
+    // Restarting locationd resets CoreMotion's relay to a 0° hinge, which folds
+    // the device. Remember where the hinge was so it can be put back.
+    const previousAngle = await readHingeAngleViaDevicectl(udid).catch(() => null);
+    const dylib = await (0, bootstrap_js_1.getFoldDylibPath)();
+    if (!dylib) {
+        throw new Error('fold control requires drivers/ios-fold/conductor-fold.dylib — build it with packages/ios-fold/tools/build-fold.sh');
+    }
+    const spawn = (args) => exec('xcrun', ['simctl', 'spawn', udid, ...args]);
+    await spawn(['launchctl', 'setenv', 'DYLD_INSERT_LIBRARIES', dylib]);
+    try {
+        await spawn(['launchctl', 'kickstart', '-k', 'system/com.apple.locationd']);
+    }
+    finally {
+        await spawn(['launchctl', 'unsetenv', 'DYLD_INSERT_LIBRARIES']).catch(() => { });
+    }
+    const deadline = Date.now() + 15000;
+    while (Date.now() < deadline) {
+        const current = await locationdPid(udid);
+        if (current && current === recordedPid(udid)) {
+            if (previousAngle !== null) {
+                fs_1.default.writeFileSync(controlPath(udid), String(previousAngle));
+            }
+            return;
+        }
+        await new Promise((r) => setTimeout(r, 300));
+    }
+    throw new Error('fold controller did not come up inside locationd (is this a foldable device?)');
+}
+/** Apply a hinge angle in degrees (0 = closed, 180 = open flat). */
+async function setFoldAngle(udid, angle) {
+    if (!Number.isFinite(angle) || angle < 0 || angle > 180) {
+        throw new Error(`fold angle must be between 0 and 180 (got ${angle})`);
+    }
+    await ensureFoldControllerInjected(udid);
+    fs_1.default.writeFileSync(controlPath(udid), String(angle));
+}
+/**
+ * Rotate through the injected relay, the way Device Hub's orientation picker
+ * does. Only needed where devicectl's setter is ignored.
+ */
+async function setOrientationViaRelay(udid, orientation) {
+    const token = exports.RELAY_ORIENTATIONS[orientation];
+    if (!token)
+        throw new Error(`no relay mapping for orientation '${orientation}'`);
+    await ensureFoldControllerInjected(udid);
+    fs_1.default.writeFileSync(orientationPath(udid), token);
+}
+/**
+ * Read the current fold state. devicectl is the authority: the hinge can be
+ * moved from Device Hub as well as by us, so anything we cached locally would
+ * only cover the folds this process happened to see.
+ */
+async function getFoldState(udid) {
+    const angle = await readHingeAngleViaDevicectl(udid);
+    return { angle, pose: poseForAngle(angle) };
+}
+/**
+ * `devicectl device motion hinge-angle` is a monitor: it prints the current
+ * angle immediately but then streams until its session expires, so take the
+ * first sample and stop it rather than waiting around.
+ */
+async function readHingeAngleViaDevicectl(udid) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)('xcrun', [
+            'devicectl',
+            'device',
+            'motion',
+            'hinge-angle',
+            '--device',
+            udid,
+            '--session-timeout',
+            '10',
+        ]);
+        let out = '';
+        let settled = false;
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            proc.kill('SIGTERM');
+            fn();
+        };
+        const timer = setTimeout(() => finish(() => reject(new Error('timed out reading hinge angle'))), 15000);
+        proc.stdout.on('data', (chunk) => {
+            out += chunk.toString();
+            const match = out.match(/Angle:\s*([0-9.]+)/);
+            if (match)
+                finish(() => resolve(Number(match[1])));
+        });
+        proc.on('error', (err) => finish(() => reject(err)));
+        proc.on('close', () => finish(() => reject(new Error('could not read hinge angle — is this a foldable device?'))));
+    });
+}

package/dist/enum-options.js

@@ -48,8 +48,38 @@ exports.ENUM_PARAMS = [
         command: 'set-orientation',
         param: '<orientation>',
         description: 'Device orientation',
-        // Source: VALID in commands/set-orientation.ts
-        values: [{ value: 'portrait' }, { value: 'landscape' }],
+        // Source: BASIC + IOS_ONLY in commands/set-orientation.ts
+        values: [
+            { value: 'portrait' },
+            { value: 'landscape' },
+            { value: 'portraitUpsideDown', description: 'iOS only' },
+            { value: 'landscapeLeft', description: 'iOS only' },
+            { value: 'landscapeRight', description: 'iOS only' },
+            { value: 'faceUp', description: 'iOS only' },
+            { value: 'faceDown', description: 'iOS only' },
+        ],
+    },
+    {
+        command: 'take-screenshot',
+        param: '--display',
+        description: 'Which display to capture (default: whichever panel is live)',
+        // Source: ROLE_ALIASES in drivers/ios-displays.ts. Any display id the
+        // device reports is also accepted, so the list is not exhaustive.
+        values: [
+            { value: 'cover', description: 'Foldable outer panel (XCUIScreen.main)' },
+            { value: 'inner', description: 'Foldable inner panel, live when unfolded' },
+        ],
+    },
+    {
+        command: 'set-fold',
+        param: '<state>',
+        description: 'Hinge state of a foldable device, or an angle from 0 to 180',
+        // Source: FOLD_POSES in drivers/ios-fold.ts
+        values: [
+            { value: 'closed', description: '0\u00b0 — folded shut, cover display active' },
+            { value: 'book', description: '130\u00b0 — half open' },
+            { value: 'open', description: '180\u00b0 — open flat' },
+        ],
     },
     {
         command: 'start-device',

package/dist/index.js

@@ -58,6 +58,8 @@ const hide_keyboard_js_1 = require("./commands/hide-keyboard.js");
 const scroll_until_visible_js_1 = require("./commands/scroll-until-visible.js");
 const set_location_js_1 = require("./commands/set-location.js");
 const set_orientation_js_1 = require("./commands/set-orientation.js");
+const fold_js_1 = require("./commands/fold.js");
+const get_orientation_js_1 = require("./commands/get-orientation.js");
 const set_viewport_js_1 = require("./commands/set-viewport.js");
 const start_device_js_1 = require("./commands/start-device.js");
 const stop_device_js_1 = require("./commands/stop-device.js");
@@ -140,6 +142,9 @@ const COMMAND_HELP = {
     travel: travel_js_1.HELP,
     'record-video': record_video_js_1.HELP,
     'set-orientation': set_orientation_js_1.HELP,
+    'get-fold': fold_js_1.HELP,
+    'set-fold': fold_js_1.HELP,
+    'get-orientation': get_orientation_js_1.HELP,
     'set-viewport': set_viewport_js_1.HELP,
     'take-screenshot': screenshot_js_1.HELP,
     'capture-ui': capture_ui_js_1.HELP,
@@ -823,6 +828,19 @@ async function main() {
             });
             break;
         }
+        case 'get-fold': {
+            exitCode = await (0, fold_js_1.getFold)(opts, sessionName);
+            break;
+        }
+        case 'set-fold': {
+            const value = String(rest[0] ?? argv['fold'] ?? '');
+            exitCode = await (0, fold_js_1.setFold)(value, opts, sessionName);
+            break;
+        }
+        case 'get-orientation': {
+            exitCode = await (0, get_orientation_js_1.getOrientation)(opts, sessionName);
+            break;
+        }
         case 'set-orientation': {
             const orientation = (rest[0] ??
                 argv['orientation'] ??
@@ -867,6 +885,7 @@ async function main() {
                 above: argv['above'],
                 leftOf: argv['left-of'],
                 rightOf: argv['right-of'],
+                display: argv['display'] !== undefined ? String(argv['display']) : undefined,
             });
             break;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.32.1",
+  "version": "0.33.1",
   "description": "CLI tool for mobile app interactions — optimized for AI agents",
   "license": "MIT",
   "repository": {

package/skills/conductor-device-setup/SKILL.md

@@ -27,10 +27,39 @@ conductor list-apps          # installed app ids / package names (--json adds ap
 | `conductor stop-device [<name-or-id>] [--all]`                        | Shut down device(s)                                                        |
 | `conductor delete-device <name-or-id> [--all]`                        | Delete simulator(s)/AVD(s)/web session(s)                                  |
 | `conductor set-location --lat <n> --lng <n>`                          | Set GPS coordinates                                                        |
-| `conductor set-orientation <portrait\|landscape>`                     | Set orientation                                                            |
+| `conductor set-orientation <portrait\|landscape\|portraitUpsideDown\|landscapeLeft\|landscapeRight\|faceUp\|faceDown>` | Set orientation (the last five are iOS only)                               |
+| `conductor get-orientation`                                           | Print the current orientation (iOS only)                                   |
+| `conductor set-fold <closed\|book\|open\|0-180>`                     | Fold/unfold a foldable device, or set an exact hinge angle (iPhone Duo)    |
+| `conductor get-fold`                                                  | Print the current hinge angle and pose                                     |
 | `conductor set-viewport [<w> <h>] [--preset mobile\|tablet\|desktop]` | Resize web viewport (web only)                                             |
 | `conductor install-web [--check] [browser]`                           | Install a Playwright browser (chromium/firefox/webkit); `--check` = status |
 
+### Foldable devices (iPhone Duo)
+
+`set-fold` drives the hinge the same way Device Hub's slider does, so the device
+really folds: SpringBoard swaps between the cover and inner displays, and
+`devicectl device motion hinge-angle` reports the new angle. `take-screenshot`
+follows the fold automatically — it captures whichever panel is live, so an
+unfolded device gives you the inner screen rather than the powered-off cover.
+Pass `--display cover` or `--display inner` to pin it to one panel, or a display
+id for anything else the device has attached (CarPlay, an external screen). An
+unknown value lists that device's displays with their ids.
+
+Angles are in degrees, 0 (shut) to 180 (flat). `closed`/`book`/`open` map to
+0/130/180. Named poses always swap the display; an arbitrary mid-way angle sets
+the hinge but may leave the cover display active, because the system decides
+when to swap on its own transition logic.
+
+The first `set-fold` after a device boots takes a few seconds: it injects a
+controller into the simulator's locationd (restarting it), because Apple ships
+no fold setter in `simctl` or `devicectl`. The current angle is restored
+afterwards, so injecting doesn't change the pose. Subsequent calls are instant. This is
+iOS-simulator only.
+
+`set-orientation` works on foldables too, but by the same route: they accept
+`devicectl`'s setter and ignore it, so the command verifies the result and
+rotates through the injected controller when needed.
+
 ### Attach to an existing browser (CDP)
 
 Instead of launching its own browser, the web driver can attach to one that's

package/skills/conductor-inspect/SKILL.md

@@ -17,7 +17,7 @@ here. Always observe before you act, and confirm after.
 | `conductor inspect [--dump]` | Print the UI hierarchy (`--dump` = raw driver output) |
 | `conductor inspect --at <x,y> [--tappable]` | Topmost view at a screen point |
 | `conductor focused [--poll [ms]]` | Metadata of the focused element. `--poll` watches changes — only with a bounded use, then stop it |
-| `conductor take-screenshot [<element>] [--output <path>] [--full-page]` | Screenshot; crop to a matched element; `--full-page` (web) |
+| `conductor take-screenshot [<element>] [--output <path>] [--full-page] [--display <panel>]` | Screenshot; crop to a matched element; `--full-page` (web); `--display cover\|inner\|<id>` picks a display (default: whichever panel is live) |
 
 `capture-ui` is the workhorse: it returns the screen as structured data **and**
 gives each element a ref like `@e3` that `conductor tap-on @e3` taps by cached