@houwert/conductor 0.29.3 → 0.31.0

package/dist/drivers/ios.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -16,6 +49,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
+const devicectl = __importStar(require("./devicectl.js"));
 /**
  * How long a captured view hierarchy may be reused. Bounds the staleness of a
  * cached snapshot when the screen changes without a driver-issued command
@@ -24,11 +58,18 @@ const child_process_1 = require("child_process");
  */
 const HIERARCHY_CACHE_TTL_MS = 750;
 class IOSDriver {
-    constructor(port = 1075, host = '127.0.0.1', deviceId, platform = 'ios') {
+    constructor(port = 1075, host = '127.0.0.1', deviceId, platform = 'ios', 
+    /**
+     * Physical devices route app lifecycle through devicectl instead of simctl,
+     * and can't offer the simulator-only conveniences (clipboard, location,
+     * TCC pre-approval, video capture).
+     */
+    isPhysical = false) {
         this.port = port;
         this.host = host;
         this.deviceId = deviceId;
         this.platform = platform;
+        this.isPhysical = isPhysical;
         this._recordingProcess = null;
         /**
          * Short-lived cache of the most recent view hierarchy, keyed by request
@@ -38,6 +79,12 @@ class IOSDriver {
          */
         this.hierarchyCache = null;
     }
+    /** Reject a simulator-only operation with a message that names the alternative. */
+    unsupportedOnDevice(operation, alternative) {
+        throw new Error(`${operation} is not supported on physical ${this.platform === 'tvos' ? 'tvOS' : 'iOS'} devices` +
+            (alternative ? ` — ${alternative}` : '') +
+            '.');
+    }
     request(method, path, body) {
         return new Promise((resolve, reject) => {
             const bodyBuf = body !== undefined ? Buffer.from(JSON.stringify(body), 'utf-8') : undefined;
@@ -193,7 +240,18 @@ class IOSDriver {
         for (const [key, value] of Object.entries(args ?? {})) {
             argPairs.push(`-${key}`, value);
         }
-        if (inject) {
+        if (this.isPhysical && (inject || argPairs.length > 0)) {
+            // devicectl is the device-side equivalent of `simctl launch`: it takes
+            // both launch arguments and an environment dictionary.
+            const deviceId = this.requireDeviceId();
+            await devicectl.launchApp(deviceId, bundleId, argPairs, inject
+                ? {
+                    DYLD_INSERT_LIBRARIES: inject.dylibPath,
+                    CONDUCTOR_INPROC_PORT: String(inject.inprocPort),
+                }
+                : undefined);
+        }
+        else if (inject) {
             // Injection requires simctl launch with SIMCTL_CHILD_ env — the XCTest
             // /launchApp path only activates and can't set environment.
             const deviceId = this.requireDeviceId();
@@ -220,6 +278,13 @@ class IOSDriver {
     }
     async clearAppState(bundleId) {
         const deviceId = this.requireDeviceId();
+        if (this.isPhysical) {
+            // No get_app_container on device, so there's no bundle to reinstall from;
+            // the caller has to supply the .app again via install-app.
+            await devicectl.uninstallApp(deviceId, bundleId);
+            this.invalidateHierarchyCache();
+            return;
+        }
         // Terminate first to prevent app from saving state after clear
         await this.simctl(['terminate', deviceId, bundleId]).catch(() => { });
         // Capture the .app bundle path before uninstalling — uninstall deletes the UUID directory
@@ -240,26 +305,40 @@ class IOSDriver {
     }
     async uninstallApp(bundleId) {
         const deviceId = this.requireDeviceId();
-        await this.simctl(['terminate', deviceId, bundleId]).catch(() => { });
-        await this.simctl(['uninstall', deviceId, bundleId]);
+        if (this.isPhysical) {
+            await devicectl.uninstallApp(deviceId, bundleId);
+        }
+        else {
+            await this.simctl(['terminate', deviceId, bundleId]).catch(() => { });
+            await this.simctl(['uninstall', deviceId, bundleId]);
+        }
         this.invalidateHierarchyCache();
     }
     async clearKeychain() {
+        if (this.isPhysical)
+            this.unsupportedOnDevice('clear-keychain');
         const deviceId = this.requireDeviceId();
         await this.simctl(['keychain', deviceId, 'reset']);
     }
     async openLink(url) {
+        if (this.isPhysical) {
+            this.unsupportedOnDevice('open-link', 'devicectl has no openurl equivalent');
+        }
         const deviceId = this.requireDeviceId();
         await this.simctl(['openurl', deviceId, url]);
         this.invalidateHierarchyCache();
     }
     /** Read the simulator's clipboard. Uses `xcrun simctl pbpaste <udid>`. */
     async clipboardRead() {
+        if (this.isPhysical)
+            this.unsupportedOnDevice('Reading the clipboard');
         const deviceId = this.requireDeviceId();
         return this.simctlCapture(['pbpaste', deviceId]);
     }
     /** Write to the simulator's clipboard. Uses `xcrun simctl pbcopy <udid>` over stdin. */
     async clipboardWrite(text) {
+        if (this.isPhysical)
+            this.unsupportedOnDevice('Writing the clipboard');
         const deviceId = this.requireDeviceId();
         await new Promise((resolve, reject) => {
             const proc = (0, child_process_1.spawn)('xcrun', ['simctl', 'pbcopy', deviceId], {
@@ -275,6 +354,8 @@ class IOSDriver {
         });
     }
     async setLocation(latitude, longitude) {
+        if (this.isPhysical)
+            this.unsupportedOnDevice('set-location');
         const deviceId = this.requireDeviceId();
         await this.simctl(['location', deviceId, 'set', `${latitude},${longitude}`]);
     }
@@ -339,6 +420,12 @@ class IOSDriver {
             mediaLibrary: 'media-library',
             siri: 'siri',
         };
+        // On device there's no TCC pre-approval path, so the runner's interruption
+        // monitor is the only thing that can answer permission dialogs.
+        if (this.isPhysical) {
+            await this.post('setPermissions', { permissions: expanded });
+            return;
+        }
         const deviceId = this.requireDeviceId();
         if (allValue !== undefined) {
             // Best-effort bulk grant/revoke. 'all' covers TCC-managed permissions but
@@ -370,6 +457,8 @@ class IOSDriver {
         await this.post('setPermissions', { permissions: expanded });
     }
     async addMedia(filePath) {
+        if (this.isPhysical)
+            this.unsupportedOnDevice('add-media');
         const deviceId = this.requireDeviceId();
         await this.simctl(['addmedia', deviceId, filePath]);
     }
@@ -380,6 +469,9 @@ class IOSDriver {
         throw new Error('getAirplaneMode is not supported on iOS simulators');
     }
     async startRecording(outputPath) {
+        if (this.isPhysical) {
+            this.unsupportedOnDevice('Screen recording', 'capture stills with `conductor screenshot`');
+        }
         const deviceId = this.requireDeviceId();
         if (this._recordingProcess)
             await this.stopRecording();

package/dist/drivers/roku/app-ui-parser.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRokuAppUI = parseRokuAppUI;
+/**
+ * Converts Roku's ECP `/query/app-ui` SceneGraph XML into the uiautomator-style
+ * `<node>` XML that conductor's Android element resolver (`parseAndroidHierarchy`,
+ * `findAndroidElement`, `inspectAndroidToText`) already understands — the same
+ * trick Vega uses, so Roku reuses the entire inspection and element-resolution path.
+ *
+ * app-ui shape:
+ * ```
+ * <app-ui>
+ *   <status>OK</status>
+ *   <topscreen>
+ *     <plugin id="dev" name="MyApp"/>
+ *     <screen focused="true" type="screen">
+ *       <RenderableNode name="myId" subtype="Group" bounds="{0, 0, 1920, 1080}" …>
+ * ```
+ * Node `name` attributes (SceneGraph node ids) become `resource-id`, `subtype`
+ * becomes `class`, and `bounds` are accumulated with parent `translation` offsets
+ * into scene-absolute `[x1,y1][x2,y2]` rects — the Android adapter's format.
+ */
+const xml_js_1 = require("../xml.js");
+const EMPTY = '<?xml version="1.0" encoding="UTF-8"?>\n<hierarchy />';
+/** Parse Roku app-ui XML and re-emit it as uiautomator `<node>` XML. */
+function parseRokuAppUI(xml, screenWidth = 1920, screenHeight = 1080) {
+    const root = (0, xml_js_1.parseXml)(xml);
+    if (!root)
+        return EMPTY;
+    const topscreen = (0, xml_js_1.childElement)(root, 'topscreen');
+    const screen = topscreen && (0, xml_js_1.childElement)(topscreen, 'screen');
+    if (!screen)
+        return EMPTY;
+    const lines = ['<?xml version="1.0" encoding="UTF-8"?>', '<hierarchy>'];
+    // A root node spanning the screen: it gives the screenshot cropper its reference
+    // bounds, matching the window node Android and Vega both emit.
+    // Never focused: `<screen focused>` means the screen holds device focus, not that
+    // it is the focused element, and claiming it here would shadow the real one.
+    const rootAttrs = [
+        'class="Screen"',
+        `bounds="[0,0][${screenWidth},${screenHeight}]"`,
+        'clickable="false"',
+        'focusable="false"',
+        'focused="false"',
+        'enabled="true"',
+    ];
+    lines.push(`  <node ${rootAttrs.join(' ')}>`);
+    emitChildren(screen, { x: 0, y: 0 }, false, lines, 2);
+    lines.push('  </node>');
+    lines.push('</hierarchy>');
+    return lines.join('\n');
+}
+function emitChildren(parent, offset, parentIsRowListItem, lines, depth) {
+    // A RowListItem's trailing Group duplicates the item it wraps.
+    const children = parentIsRowListItem && parent.children.length > 1
+        ? parent.children.slice(0, -1)
+        : parent.children;
+    for (const child of children)
+        emitNode(child, offset, parentIsRowListItem, lines, depth);
+}
+function emitNode(node, parentOffset, parentIsRowListItem, lines, depth) {
+    // SceneGraph doesn't render an invisible node or anything beneath it, but ECP
+    // still reports the subtree with real bounds. Keeping them would let
+    // assert-visible match a hidden element and assert-not-visible fail on one.
+    if (node.attrs['visible'] === 'false')
+        return;
+    const opacity = parseFloat(node.attrs['opacity'] ?? '100');
+    if (!isNaN(opacity) && opacity <= 0)
+        return;
+    // ECP reports the SceneGraph type in `subtype`; the element name is only a
+    // fallback, and for a generic `RenderableNode` it says nothing at all.
+    const subtype = node.attrs['subtype'] || (node.tag === 'RenderableNode' ? 'Group' : node.tag);
+    const translation = parseNumericArray(node.attrs['translation'], 2);
+    const bounds = parseNumericArray(node.attrs['bounds'], 4);
+    // Offset this node's children inherit.
+    let nodeOffset = parentOffset;
+    if (subtype === 'MarkupGrid' && parentIsRowListItem) {
+        if (bounds)
+            nodeOffset = { x: bounds[0] + parentOffset.x, y: bounds[1] + parentOffset.y };
+    }
+    else if (translation) {
+        nodeOffset = { x: translation[0] + parentOffset.x, y: translation[1] + parentOffset.y };
+    }
+    const focusable = node.attrs['focusable'] === 'true';
+    const focused = node.attrs['focused'] === 'true';
+    const attrs = [`class="${(0, xml_js_1.xmlEscape)(subtype)}"`];
+    if (node.attrs['name'])
+        attrs.push(`resource-id="${(0, xml_js_1.xmlEscape)(node.attrs['name'])}"`);
+    if (node.attrs['text'])
+        attrs.push(`text="${(0, xml_js_1.xmlEscape)(node.attrs['text'])}"`);
+    if (bounds) {
+        const x1 = Math.round(bounds[0] + parentOffset.x);
+        const y1 = Math.round(bounds[1] + parentOffset.y);
+        attrs.push(`bounds="[${x1},${y1}][${x1 + Math.round(bounds[2])},${y1 + Math.round(bounds[3])}]"`);
+    }
+    attrs.push(`clickable="${focusable}"`, `focusable="${focusable}"`);
+    attrs.push(`focused="${focused}"`, `selected="${focused}"`, 'enabled="true"');
+    const indent = '  '.repeat(depth);
+    if (node.children.length === 0) {
+        lines.push(`${indent}<node ${attrs.join(' ')} />`);
+        return;
+    }
+    lines.push(`${indent}<node ${attrs.join(' ')}>`);
+    emitChildren(node, nodeOffset, node.tag === 'RowListItem', lines, depth + 1);
+    lines.push(`${indent}</node>`);
+}
+/**
+ * Parses a Roku numeric array attribute (`{0, 0, 1920, 1080}`), or null if it
+ * doesn't hold at least `minSize` values — callers index it positionally, so a
+ * short array is no more usable than a missing one.
+ */
+function parseNumericArray(value, minSize) {
+    if (!value)
+        return null;
+    const cleaned = value.replace(/[{}]/g, '').trim();
+    if (!cleaned)
+        return null;
+    const parsed = cleaned.split(',').map((p) => parseFloat(p.trim()));
+    if (parsed.length < minSize || parsed.some((v) => isNaN(v)))
+        return null;
+    return parsed;
+}

package/dist/drivers/roku/discovery.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rokuPassword = rokuPassword;
+exports.discoverRokuDevices = discoverRokuDevices;
+exports.describe = describe;
+exports.isPortOpen = isPortOpen;
+exports.parseSsdpLocation = parseSsdpLocation;
+/**
+ * Discovers Roku devices on the local network. Two best-effort methods:
+ *  1. `CONDUCTOR_ROKU_HOST` — a manually pinned device IP/hostname (always checked).
+ *  2. SSDP multicast (`M-SEARCH` with `ST: roku:ecp`) — opt-in via
+ *     `CONDUCTOR_ROKU_DISCOVERY`, because the scan multicasts on the LAN and adds
+ *     ~1s to every device listing.
+ */
+const dgram_1 = __importDefault(require("dgram"));
+const net_1 = __importDefault(require("net"));
+const verbose_js_1 = require("../../verbose.js");
+const ecp_client_js_1 = require("./ecp-client.js");
+const SSDP_ADDRESS = '239.255.255.250';
+const SSDP_PORT = 1900;
+const SSDP_TIMEOUT_MS = 1000;
+const PROBE_TIMEOUT_MS = 500;
+/** The dev-mode password used for screenshots, from the environment. */
+function rokuPassword() {
+    return process.env.CONDUCTOR_ROKU_PASSWORD ?? '';
+}
+function discoveryEnabled() {
+    const v = (process.env.CONDUCTOR_ROKU_DISCOVERY ?? '').toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes';
+}
+/** All Roku devices reachable right now: the pinned env-var host plus any SSDP hits. */
+async function discoverRokuDevices() {
+    const hosts = new Set();
+    const pinned = process.env.CONDUCTOR_ROKU_HOST?.trim();
+    if (pinned)
+        hosts.add(pinned);
+    if (discoveryEnabled()) {
+        for (const host of await ssdpScan())
+            hosts.add(host);
+    }
+    const described = await Promise.all([...hosts].map((host) => describe(host)));
+    return described.filter((d) => d !== null);
+}
+/** Resolve a host into a described device, or null if it isn't reachable. */
+async function describe(host) {
+    if (!(await isPortOpen(host, ecp_client_js_1.DEFAULT_ECP_PORT))) {
+        (0, verbose_js_1.log)(`roku: device at ${host} is not reachable on port ${ecp_client_js_1.DEFAULT_ECP_PORT}`);
+        return null;
+    }
+    const info = await new ecp_client_js_1.RokuEcpClient(host).getDeviceInfo();
+    return {
+        host,
+        modelName: info?.modelName ?? 'Roku Device',
+        friendlyName: info?.friendlyName || host,
+        serialNumber: info?.serialNumber ?? '',
+        softwareVersion: info?.softwareVersion ?? '',
+    };
+}
+/** Quick TCP probe so an offline pinned host fails in ~500ms, not a full HTTP timeout. */
+function isPortOpen(host, port) {
+    return new Promise((resolve) => {
+        const socket = new net_1.default.Socket();
+        const done = (result) => {
+            socket.destroy();
+            resolve(result);
+        };
+        socket.setTimeout(PROBE_TIMEOUT_MS);
+        socket.once('connect', () => done(true));
+        socket.once('timeout', () => done(false));
+        socket.once('error', () => done(false));
+        socket.connect(port, host);
+    });
+}
+/** SSDP M-SEARCH for `roku:ecp` targets; resolves to the responding hosts. */
+function ssdpScan() {
+    const request = Buffer.from([
+        'M-SEARCH * HTTP/1.1',
+        `HOST: ${SSDP_ADDRESS}:${SSDP_PORT}`,
+        'MAN: "ssdp:discover"',
+        'ST: roku:ecp',
+        'MX: 1',
+        '',
+        '',
+    ].join('\r\n'));
+    return new Promise((resolve) => {
+        const hosts = new Set();
+        const socket = dgram_1.default.createSocket({ type: 'udp4', reuseAddr: true });
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                socket.close();
+            }
+            catch {
+                /* already closed */
+            }
+            resolve([...hosts]);
+        };
+        const timer = setTimeout(finish, SSDP_TIMEOUT_MS);
+        socket.on('message', (msg) => {
+            const host = parseSsdpLocation(msg.toString('utf-8'));
+            if (host)
+                hosts.add(host);
+        });
+        socket.on('error', (err) => {
+            (0, verbose_js_1.log)(`roku: SSDP scan failed: ${err.message}`);
+            finish();
+        });
+        socket.bind(() => {
+            socket.send(request, SSDP_PORT, SSDP_ADDRESS, (err) => {
+                if (err) {
+                    (0, verbose_js_1.log)(`roku: SSDP send failed: ${err.message}`);
+                    finish();
+                }
+            });
+        });
+    });
+}
+/** Extract the device host from an SSDP response's `LOCATION: http://<ip>:8060/` header. */
+function parseSsdpLocation(response) {
+    const line = response.split(/\r?\n/).find((l) => /^location:/i.test(l));
+    if (!line)
+        return null;
+    try {
+        return new URL(line.slice(line.indexOf(':') + 1).trim()).hostname || null;
+    }
+    catch {
+        return null;
+    }
+}