@houwert/conductor 0.33.0 → 0.33.2

package/dist/commands/screenshot.js

@@ -4,9 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
+exports.captureScreen = captureScreen;
 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 +24,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");
@@ -32,7 +40,63 @@ const roku_js_1 = require("../drivers/roku.js");
 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 exec = (0, util_1.promisify)(child_process_1.execFile);
 const DEFAULT_MARGIN_PX = 8;
+/**
+ * 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) {
+    if (!(driver instanceof ios_js_1.IOSDriver)) {
+        if (displayOverride) {
+            throw new Error('--display is iOS-only; other platforms expose a single screen');
+        }
+        return { buffer: await driver.screenshot(opts), redirected: false };
+    }
+    const deviceId = driver.deviceId;
+    if (!deviceId) {
+        if (displayOverride)
+            throw new Error('--display needs a device to query for its displays');
+        return { buffer: await driver.screenshot(opts), redirected: false };
+    }
+    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 { buffer: await driver.screenshot(opts), redirected: false };
+    }
+    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 { buffer: await driver.screenshot(opts), redirected: false };
+    }
+    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 { buffer: await promises_1.default.readFile(file), redirected: true };
+    }
+    catch (err) {
+        throw new Error(`could not capture display ${choice.displayId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    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,8 +127,13 @@ 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 { buffer: buf, redirected } = await captureScreen(driver, { fullPage }, flags.display);
         let out = buf;
+        if (sel && redirected) {
+            throw new Error('cropping to an element is not supported on this display yet — the panel is ' +
+                'rotated relative to the accessibility coordinate space. Re-run with ' +
+                '--display cover, or fold the device, to crop against the main panel.');
+        }
         if (sel) {
             let el;
             let hierarchyW;

package/dist/drivers/devicectl.js

@@ -17,6 +17,7 @@ exports.terminateApp = terminateApp;
 exports.listApps = listApps;
 exports.getOrientation = getOrientation;
 exports.setOrientation = setOrientation;
+exports.listDisplays = listDisplays;
 /**
  * `xcrun devicectl` wrapper — the physical-device counterpart to `simctl`.
  *
@@ -269,3 +270,26 @@ async function getOrientation(deviceId) {
 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/enum-options.js

@@ -59,6 +59,17 @@ exports.ENUM_PARAMS = [
             { 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>',

package/dist/index.js

@@ -885,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.33.0",
+  "version": "0.33.2",
   "description": "CLI tool for mobile app interactions — optimized for AI agents",
   "license": "MIT",
   "repository": {

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

@@ -39,8 +39,16 @@ conductor list-apps          # installed app ids / package names (--json adds ap
 `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`
-captures whichever display is active; to grab a specific panel directly, use
-`xcrun simctl io <device> screenshot --display <1|3>` (1 = cover, 3 = inner).
+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.
+
+Cropping a screenshot to an element (`take-screenshot <element>`) only works
+against the main panel: the inner panel's framebuffer is rotated relative to the
+accessibility coordinate space, so conductor refuses the crop there instead of
+returning the wrong region. Fold the device or pass `--display cover` to crop.
 
 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

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