@houwert/conductor 0.2.0 → 0.3.0

package/dist/device-picker.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickDevice = pickDevice;
+const readline_1 = require("readline");
+const list_devices_js_1 = require("./commands/list-devices.js");
+/**
+ * Discover booted devices and let the user pick one interactively
+ * when multiple are found.
+ *
+ * - 0 devices → returns undefined
+ * - 1 device  → returns it automatically
+ * - N devices + TTY → shows a numbered picker
+ * - N devices + no TTY → returns undefined (caller should error)
+ */
+async function pickDevice() {
+    const devices = await (0, list_devices_js_1.discoverBootedDevices)();
+    if (devices.length === 0)
+        return undefined;
+    if (devices.length === 1)
+        return devices[0].id;
+    // Non-interactive context — can't prompt
+    if (!process.stdin.isTTY) {
+        console.error(`Multiple devices found but stdin is not a TTY. Use --device to specify one:\n` +
+            devices.map((d) => `  ${d.id}  ${d.name} (${d.platform})`).join('\n'));
+        return undefined;
+    }
+    console.log('Multiple devices detected — pick one:\n');
+    for (let i = 0; i < devices.length; i++) {
+        const d = devices[i];
+        console.log(`  ${i + 1}) ${d.name}  (${d.platform}, ${d.id})`);
+    }
+    console.log();
+    const choice = await promptChoice(devices.length);
+    if (choice === null)
+        return undefined;
+    const picked = devices[choice];
+    console.log(`Using ${picked.name} (${picked.id})\n`);
+    return picked.id;
+}
+function promptChoice(max) {
+    return new Promise((resolve) => {
+        const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+        let resolved = false;
+        const done = (value) => {
+            if (resolved)
+                return;
+            resolved = true;
+            rl.close();
+            resolve(value);
+        };
+        const ask = () => {
+            rl.question(`Enter 1–${max}: `, (answer) => {
+                const n = parseInt(answer.trim(), 10);
+                if (n >= 1 && n <= max) {
+                    done(n - 1);
+                }
+                else {
+                    ask();
+                }
+            });
+        };
+        rl.on('close', () => done(null));
+        ask();
+    });
+}

package/dist/drivers/android.js

@@ -84,29 +84,21 @@ class AndroidDriver {
             'grpc.keepalive_timeout_ms': 20000,
         });
     }
-    async close() {
+    close() {
         if (this.client) {
-            await new Promise((resolve) => this.client.close(() => resolve()));
+            this.client.close();
             this.client = null;
         }
     }
-    async isAlive() {
-        try {
-            await this.deviceInfo();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    call(method, req) {
+    call(method, req, timeoutMs = 30000) {
         return new Promise((resolve, reject) => {
             if (!this.client) {
                 reject(new Error('AndroidDriver: not connected'));
                 return;
             }
+            const deadline = new Date(Date.now() + timeoutMs);
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.client[method](req, (err, resp) => {
+            this.client[method](req, { deadline }, (err, resp) => {
                 if (err)
                     reject(err);
                 else
@@ -114,6 +106,15 @@ class AndroidDriver {
             });
         });
     }
+    async isAlive() {
+        try {
+            await this.call('deviceInfo', {}, 5000);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async deviceInfo() {
         const resp = await this.call('deviceInfo', {});
         return { widthPixels: resp.widthPixels, heightPixels: resp.heightPixels };

package/dist/drivers/bootstrap.js

@@ -10,6 +10,9 @@ exports.isSimulatorBooted = isSimulatorBooted;
 exports.isPortOpen = isPortOpen;
 exports.startIOSDriver = startIOSDriver;
 exports.stopIOSDriver = stopIOSDriver;
+exports.setupTvOSDriverCache = setupTvOSDriverCache;
+exports.startTvOSDriver = startTvOSDriver;
+exports.stopTvOSDriver = stopTvOSDriver;
 exports.startAndroidDriver = startAndroidDriver;
 exports.stopAndroidDriver = stopAndroidDriver;
 exports.uninstallDriver = uninstallDriver;
@@ -24,6 +27,7 @@ exports.uninstallDriver = uninstallDriver;
  * drivers/ios/ — no separate Conductor/JVM installation required.
  */
 const child_process_1 = require("child_process");
+const http_1 = __importDefault(require("http"));
 const net_1 = __importDefault(require("net"));
 const os_1 = __importDefault(require("os"));
 const fs_1 = __importDefault(require("fs"));
@@ -35,9 +39,24 @@ const _platformCache = new Map();
 async function detectPlatform(deviceId) {
     if (_platformCache.has(deviceId))
         return _platformCache.get(deviceId);
-    // Check if it looks like an iOS simulator UUID (8-4-4-4-12 hex chars)
+    // Check if it looks like an iOS/tvOS simulator UUID (8-4-4-4-12 hex chars)
     const iosUuidRe = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
     if (iosUuidRe.test(deviceId)) {
+        // Query simctl to determine whether this UUID belongs to a tvOS runtime
+        try {
+            const out = await spawnCapture('xcrun', ['simctl', 'list', 'devices', '--json']);
+            const parsed = JSON.parse(out);
+            for (const [runtime, sims] of Object.entries(parsed.devices)) {
+                if (sims.some((s) => s.udid === deviceId)) {
+                    const platform = runtime.includes('tvOS') ? 'tvos' : 'ios';
+                    _platformCache.set(deviceId, platform);
+                    return platform;
+                }
+            }
+        }
+        catch {
+            /* fall through to ios default */
+        }
         _platformCache.set(deviceId, 'ios');
         return 'ios';
     }
@@ -47,6 +66,7 @@ async function detectPlatform(deviceId) {
 }
 // ── Port management ───────────────────────────────────────────────────────────
 const IOS_BASE_PORT = 1075;
+const TVOS_BASE_PORT = 2075;
 const ANDROID_BASE_PORT = 3763;
 const PORT_FILE = path_1.default.join(os_1.default.homedir(), '.conductor', 'ports.json');
 const PORT_LOCK = PORT_FILE + '.lock';
@@ -56,7 +76,12 @@ function readPortState() {
         return JSON.parse(fs_1.default.readFileSync(PORT_FILE, 'utf-8'));
     }
     catch {
-        return { assignments: {}, nextIosPort: IOS_BASE_PORT, nextAndroidPort: ANDROID_BASE_PORT };
+        return {
+            assignments: {},
+            nextIosPort: IOS_BASE_PORT,
+            nextTvosPort: TVOS_BASE_PORT,
+            nextAndroidPort: ANDROID_BASE_PORT,
+        };
     }
 }
 function writePortState(state) {
@@ -99,7 +124,19 @@ async function getDriverPort(platform, deviceId) {
         if (state.assignments[deviceId] !== undefined) {
             return state.assignments[deviceId];
         }
-        const port = platform === 'ios' ? state.nextIosPort++ : state.nextAndroidPort++;
+        // Ensure tvos counter is initialised for port files created before tvOS support
+        if (state.nextTvosPort === undefined)
+            state.nextTvosPort = TVOS_BASE_PORT;
+        let port;
+        if (platform === 'ios') {
+            port = state.nextIosPort++;
+        }
+        else if (platform === 'tvos') {
+            port = state.nextTvosPort++;
+        }
+        else {
+            port = state.nextAndroidPort++;
+        }
         state.assignments[deviceId] = port;
         writePortState(state);
         return port;
@@ -235,10 +272,19 @@ async function startIOSDriver(deviceId, port = IOS_BASE_PORT) {
     (0, verbose_js_1.log)(`Starting iOS XCTest driver for device ${deviceId} on port ${port}`);
     await setupIOSDriverCache();
     const xctestrun = path_1.default.join(IOS_DRIVER_CACHE, 'conductor-driver-ios-config.xctestrun');
+    // Inject PORT into the xctestrun EnvironmentVariables so the XCTest runner
+    // picks it up. Env vars on the spawn call don't reach the test process —
+    // xcodebuild only passes what's declared in the xctestrun plist.
+    await spawnAndWait('plutil', [
+        '-replace',
+        'conductor-driver-iosUITests.EnvironmentVariables.PORT',
+        '-string',
+        String(port),
+        xctestrun,
+    ]);
     const proc = (0, child_process_1.spawn)('xcodebuild', ['test-without-building', '-xctestrun', xctestrun, '-destination', `id=${deviceId}`], {
         detached: true,
         stdio: ['ignore', 'ignore', 'ignore'],
-        env: { ...process.env, TEST_RUNNER_PORT: String(port) },
     });
     proc.unref();
     const deadline = Date.now() + IOS_STARTUP_TIMEOUT_MS;
@@ -257,6 +303,108 @@ async function startIOSDriver(deviceId, port = IOS_BASE_PORT) {
 async function stopIOSDriver(deviceId) {
     await spawnAndWait('xcrun', ['simctl', 'terminate', deviceId, IOS_RUNNER_BUNDLE_ID]);
 }
+// ── tvOS bootstrap ────────────────────────────────────────────────────────────
+const TVOS_RUNNER_BUNDLE_ID = 'dev.houwert.conductor-driver-tvosUITests.xctrunner';
+const TVOS_STARTUP_TIMEOUT_MS = 120000;
+const TVOS_STARTUP_POLL_MS = 500;
+// Persistent cache for extracted tvOS driver files (~/.conductor/tvos-driver/).
+// __TESTROOT__ in the xctestrun resolves to this directory, so both the xctestrun
+// and the Debug-appletvsimulator/ folder must live here.
+const TVOS_DRIVER_CACHE = path_1.default.join(os_1.default.homedir(), '.conductor', 'tvos-driver');
+/**
+ * Ensure the tvOS driver files are extracted from the bundled zips into the cache
+ * dir. Re-extracts only when the bundled xctestrun has changed (tracked by mtime).
+ */
+async function setupTvOSDriverCache() {
+    const bundledXctestrun = path_1.default.join(BUNDLED_DRIVERS_DIR, 'tvos', 'conductor-driver-tvos-config.xctestrun');
+    const bundledDriverZip = path_1.default.join(BUNDLED_DRIVERS_DIR, 'tvos', 'conductor-driver-tvos.zip');
+    const bundledRunnerZip = path_1.default.join(BUNDLED_DRIVERS_DIR, 'tvos', 'conductor-driver-tvosUITests-Runner.zip');
+    if (!fs_1.default.existsSync(bundledXctestrun) ||
+        !fs_1.default.existsSync(bundledDriverZip) ||
+        !fs_1.default.existsSync(bundledRunnerZip)) {
+        throw new Error(`Conductor tvOS driver files not found at ${path_1.default.join(BUNDLED_DRIVERS_DIR, 'tvos')}.\n` +
+            `Run 'make package-cli' from the repo root to build and bundle the drivers.`);
+    }
+    const versionFile = path_1.default.join(TVOS_DRIVER_CACHE, '.version');
+    const xctestrunMtime = String(fs_1.default.statSync(bundledXctestrun).mtimeMs);
+    let cachedMtime = '';
+    try {
+        cachedMtime = fs_1.default.readFileSync(versionFile, 'utf-8').trim();
+    }
+    catch {
+        /* first run */
+    }
+    const runnerApp = path_1.default.join(TVOS_DRIVER_CACHE, 'Debug-appletvsimulator', 'conductor-driver-tvosUITests-Runner.app');
+    if (cachedMtime === xctestrunMtime && fs_1.default.existsSync(runnerApp))
+        return;
+    (0, verbose_js_1.log)('Extracting tvOS driver files to cache...');
+    fs_1.default.rmSync(TVOS_DRIVER_CACHE, { recursive: true, force: true });
+    fs_1.default.mkdirSync(TVOS_DRIVER_CACHE, { recursive: true });
+    // Copy xctestrun directly
+    fs_1.default.copyFileSync(bundledXctestrun, path_1.default.join(TVOS_DRIVER_CACHE, 'conductor-driver-tvos-config.xctestrun'));
+    // Unzip the two .app bundles
+    const appsDir = path_1.default.join(TVOS_DRIVER_CACHE, 'Debug-appletvsimulator');
+    await spawnAndWait('unzip', ['-q', '-o', bundledDriverZip, '-d', appsDir]);
+    await spawnAndWait('unzip', ['-q', '-o', bundledRunnerZip, '-d', appsDir]);
+    fs_1.default.writeFileSync(versionFile, xctestrunMtime);
+    (0, verbose_js_1.log)('tvOS driver cache ready');
+}
+/**
+ * Start the tvOS XCTest driver via `xcodebuild test-without-building`.
+ * Mirrors startIOSDriver but targets the tvOS xctestrun.
+ *
+ * On first launch the runner app appears in the foreground, so we press the
+ * home button to dismiss it. On subsequent restarts (e.g. health-check recovery)
+ * we skip the dismiss to avoid disrupting the user's navigation state.
+ */
+async function startTvOSDriver(deviceId, port = TVOS_BASE_PORT, dismissAfterLaunch = false) {
+    if (await isPortOpen(port)) {
+        (0, verbose_js_1.log)(`tvOS driver already running on port ${port}`);
+        return;
+    }
+    (0, verbose_js_1.log)(`Starting tvOS XCTest driver for device ${deviceId} on port ${port}`);
+    await setupTvOSDriverCache();
+    const xctestrun = path_1.default.join(TVOS_DRIVER_CACHE, 'conductor-driver-tvos-config.xctestrun');
+    // Inject PORT into the xctestrun EnvironmentVariables so the XCTest runner
+    // picks it up. Env vars on the spawn call don't reach the test process —
+    // xcodebuild only passes what's declared in the xctestrun plist.
+    await spawnAndWait('plutil', [
+        '-replace',
+        'conductor-driver-tvosUITests.EnvironmentVariables.PORT',
+        '-string',
+        String(port),
+        xctestrun,
+    ]);
+    const proc = (0, child_process_1.spawn)('xcodebuild', ['test-without-building', '-xctestrun', xctestrun, '-destination', `id=${deviceId}`], {
+        detached: true,
+        stdio: ['ignore', 'ignore', 'ignore'],
+    });
+    proc.unref();
+    const deadline = Date.now() + TVOS_STARTUP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await (0, utils_js_1.sleep)(TVOS_STARTUP_POLL_MS);
+        if (await isPortOpen(port)) {
+            (0, verbose_js_1.log)(`tvOS driver ready on port ${port}`);
+            if (dismissAfterLaunch) {
+                try {
+                    await pressButtonViaDriver(port, 'home');
+                    (0, verbose_js_1.log)('Dismissed tvOS driver app');
+                }
+                catch {
+                    (0, verbose_js_1.log)('Could not dismiss tvOS driver app (non-fatal)');
+                }
+            }
+            return;
+        }
+    }
+    throw new Error(`tvOS XCTest driver did not start within ${TVOS_STARTUP_TIMEOUT_MS / 1000}s on port ${port}.`);
+}
+/**
+ * Stop the tvOS XCTest driver by terminating the runner app.
+ */
+async function stopTvOSDriver(deviceId) {
+    await spawnAndWait('xcrun', ['simctl', 'terminate', deviceId, TVOS_RUNNER_BUNDLE_ID]);
+}
 // ── Android bootstrap ─────────────────────────────────────────────────────────
 const ANDROID_STARTUP_TIMEOUT_MS = 30000;
 const ANDROID_STARTUP_POLL_MS = 500;
@@ -321,7 +469,7 @@ async function startAndroidDriver(deviceId, port = ANDROID_BASE_PORT) {
         `Make sure the Conductor driver APK is installed on device ${deviceId}.\n` +
         `Try running: conductor install --device ${deviceId}`);
 }
-async function stopAndroidDriver(deviceId) {
+async function stopAndroidDriver(deviceId, port = ANDROID_BASE_PORT) {
     await spawnAndWait('adb', [
         '-s',
         deviceId,
@@ -330,7 +478,7 @@ async function stopAndroidDriver(deviceId) {
         'force-stop',
         'dev.houwert.conductor',
     ]).catch(() => { });
-    await spawnAndWait('adb', ['-s', deviceId, 'forward', '--remove', 'tcp:3763']).catch(() => { });
+    await spawnAndWait('adb', ['-s', deviceId, 'forward', '--remove', `tcp:${port}`]).catch(() => { });
 }
 /**
  * Uninstall the Conductor driver app(s) from the device.
@@ -345,12 +493,37 @@ async function uninstallDriver(deviceId, platform) {
             'dev.houwert.conductor-driver-iosUITests.xctrunner',
         ]).catch(() => { });
     }
+    else if (platform === 'tvos') {
+        await spawnAndWait('xcrun', ['simctl', 'uninstall', deviceId, TVOS_RUNNER_BUNDLE_ID]).catch(() => { });
+    }
     else {
         await spawnAndWait('adb', ['-s', deviceId, 'uninstall', 'dev.houwert.conductor']).catch(() => { });
         await spawnAndWait('adb', ['-s', deviceId, 'uninstall', 'dev.houwert.conductor.test']).catch(() => { });
     }
 }
 // ── Helpers ───────────────────────────────────────────────────────────────────
+/** Send a pressButton command directly to the driver HTTP server. */
+function pressButtonViaDriver(port, button) {
+    return new Promise((resolve, reject) => {
+        const body = JSON.stringify({ button });
+        const options = {
+            hostname: '127.0.0.1',
+            port,
+            path: '/pressButton',
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+        };
+        const req = http_1.default.request(options, (res) => {
+            res.resume();
+            res.on('end', () => res.statusCode && res.statusCode < 300
+                ? resolve()
+                : reject(new Error(`HTTP ${res.statusCode}`)));
+        });
+        req.on('error', reject);
+        req.write(body);
+        req.end();
+    });
+}
 function spawnAndWait(cmd, args) {
     return new Promise((resolve, reject) => {
         const proc = (0, child_process_1.spawn)(cmd, args, { stdio: 'ignore' });

package/dist/drivers/element-resolver.js

@@ -212,12 +212,22 @@ function parseAndroidHierarchy(xml) {
             text: attrs['text'] ?? '',
             resourceId: attrs['resource-id'] ?? '',
             contentDesc: attrs['content-desc'] ?? '',
+            className: attrs['class'] ?? '',
+            packageName: attrs['package'] ?? '',
             bounds,
             clickable: attrs['clickable'] === 'true',
             enabled: attrs['enabled'] === 'true',
             checked: attrs['checked'] === 'true',
             focused: attrs['focused'] === 'true',
+            focusable: attrs['focusable'] === 'true',
             selected: attrs['selected'] === 'true',
+            checkable: attrs['checkable'] === 'true',
+            longClickable: attrs['long-clickable'] === 'true',
+            scrollable: attrs['scrollable'] === 'true',
+            password: attrs['password'] === 'true',
+            visibleToUser: attrs['visible-to-user'] === 'true',
+            hintText: attrs['hintText'] ?? '',
+            error: attrs['error'] ?? '',
             children: [],
             index: nodes.length,
         });

package/dist/drivers/flow-runner.js

@@ -330,11 +330,12 @@ const ANDROID_KEYCODES = {
     VOLUME_UP: 24,
     VOLUME_DOWN: 25,
     POWER: 26,
-    DPAD_UP: 19,
-    DPAD_DOWN: 20,
-    DPAD_LEFT: 21,
-    DPAD_RIGHT: 22,
-    DPAD_CENTER: 23,
+    // Android TV remote D-pad keys only
+    'REMOTE DPAD UP': 19,
+    'REMOTE DPAD DOWN': 20,
+    'REMOTE DPAD LEFT': 21,
+    'REMOTE DPAD RIGHT': 22,
+    'REMOTE DPAD CENTER': 23,
 };
 async function executeFlow(flow, driver, opts = {}) {
     const cliEnv = opts.env ?? {};

package/dist/drivers/ios.js

@@ -17,10 +17,11 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 class IOSDriver {
-    constructor(port = 1075, host = '127.0.0.1', deviceId) {
+    constructor(port = 1075, host = '127.0.0.1', deviceId, platform = 'ios') {
         this.port = port;
         this.host = host;
         this.deviceId = deviceId;
+        this.platform = platform;
         this._recordingProcess = null;
     }
     request(method, path, body) {