@houwert/conductor 0.2.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "conductor",
+  "description": "CLI for mobile UI testing, designed for AI agents",
+  "repository": "https://github.com/houwert/conductor",
+  "author": { "name": "Houwert" }
+}

package/README.md

@@ -0,0 +1,39 @@
+# Conductor
+
+A token-efficient CLI for mobile UI testing, designed for AI agents.
+
+Inspired by [`@playwright/cli`](https://github.com/microsoft/playwright-cli), this is a TypeScript reimplementation and partial fork of [Maestro](https://github.com/mobile-dev-inc/maestro) that talks directly to the bundled native drivers — no external CLI installation required.
+
+## Installation
+
+```bash
+pnpm install
+pnpm build
+pnpm link --global
+```
+
+## Quick Start
+
+```bash
+conductor list-devices
+conductor launch-app com.example.myapp
+conductor tap "Sign In"
+conductor type "user@example.com"
+conductor screenshot --output /tmp/screen.png
+```
+
+## Documentation
+
+See [`skills/conductor/SKILL.md`](./skills/conductor/SKILL.md) for full command reference.
+
+## Requirements
+
+- Android: `adb` on `PATH` with a running emulator/device
+- iOS: Xcode with a running simulator
+
+## Architecture
+
+- `src/session.ts` — persists `appId` + `deviceId` in `~/.conductor/session.json`
+- `src/runner.ts` — resolves devices, manages driver lifecycle, executes flows natively
+- `src/commands/` — one file per command
+- `src/index.ts` — argument parsing with `minimist`, command dispatch

package/dist/commands/assert-not-visible.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNotVisible = assertNotVisible;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+const wait_js_1 = require("../drivers/wait.js");
+async function assertNotVisible(element, opts = {}, sessionName = 'default', flags = {}) {
+    if (!element && !flags.id && !flags.text) {
+        (0, output_js_1.printError)('assert-not-visible requires <element> or --id <id>', opts);
+        return 1;
+    }
+    const sel = {
+        ...(flags.text ? { text: flags.text } : flags.id ? { id: flags.id } : { query: element }),
+        ...(flags.index !== undefined && { index: flags.index }),
+        ...(flags.focused !== undefined && { focused: flags.focused }),
+        ...(flags.enabled !== undefined && { enabled: flags.enabled }),
+        ...(flags.checked !== undefined && { checked: flags.checked }),
+        ...(flags.selected !== undefined && { selected: flags.selected }),
+        ...(flags.below && { below: { query: flags.below } }),
+        ...(flags.above && { above: { query: flags.above } }),
+        ...(flags.leftOf && { leftOf: { query: flags.leftOf } }),
+        ...(flags.rightOf && { rightOf: { query: flags.rightOf } }),
+    };
+    const label = flags.text
+        ? `text="${flags.text}"`
+        : flags.id
+            ? `id="${flags.id}"`
+            : `"${element}"`;
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        if (driver instanceof ios_js_1.IOSDriver) {
+            await (0, wait_js_1.waitUntilIOSElementGone)(() => driver.viewHierarchy().then((h) => h.axElement), sel, flags.timeout);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            await (0, wait_js_1.waitUntilAndroidElementGone)(() => driver.viewHierarchy(), sel, flags.timeout);
+        }
+        (0, output_js_1.printSuccess)(`assert-not-visible ${label} — element not found`, opts);
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        (0, output_js_1.printError)(`assert-not-visible ${label} — ${msg}`, opts);
+        return 1;
+    }
+}

package/dist/commands/assert-visible.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertVisible = assertVisible;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+const wait_js_1 = require("../drivers/wait.js");
+async function assertVisible(element, opts = {}, sessionName = 'default', flags = {}) {
+    if (!element && !flags.id && !flags.text) {
+        (0, output_js_1.printError)('assert-visible requires <element> or --id <id>', opts);
+        return 1;
+    }
+    const sel = {
+        ...(flags.text ? { text: flags.text } : flags.id ? { id: flags.id } : { query: element }),
+        ...(flags.index !== undefined && { index: flags.index }),
+        ...(flags.focused !== undefined && { focused: flags.focused }),
+        ...(flags.enabled !== undefined && { enabled: flags.enabled }),
+        ...(flags.checked !== undefined && { checked: flags.checked }),
+        ...(flags.selected !== undefined && { selected: flags.selected }),
+        ...(flags.below && { below: { query: flags.below } }),
+        ...(flags.above && { above: { query: flags.above } }),
+        ...(flags.leftOf && { leftOf: { query: flags.leftOf } }),
+        ...(flags.rightOf && { rightOf: { query: flags.rightOf } }),
+    };
+    const label = flags.text
+        ? `text="${flags.text}"`
+        : flags.id
+            ? `id="${flags.id}"`
+            : `"${element}"`;
+    const timeoutMs = flags.timeout ?? (flags.optional ? wait_js_1.OPTIONAL_TIMEOUT_MS : undefined);
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        const find = async () => {
+            if (driver instanceof ios_js_1.IOSDriver) {
+                return (0, wait_js_1.waitForIOSElement)(() => driver.viewHierarchy().then((h) => h.axElement), sel, timeoutMs);
+            }
+            else if (driver instanceof android_js_1.AndroidDriver) {
+                return (0, wait_js_1.waitForAndroidElement)(() => driver.viewHierarchy(), sel, timeoutMs);
+            }
+        };
+        if (flags.optional) {
+            await find().catch(() => {
+                /* not found — acceptable */
+            });
+        }
+        else {
+            await find();
+        }
+        (0, output_js_1.printSuccess)(`assert-visible ${label} — element found`, opts);
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        (0, output_js_1.printError)(`assert-visible ${label} — ${msg}`, opts);
+        return 1;
+    }
+}

package/dist/commands/back.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.back = back;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+async function back(opts = {}, sessionName = 'default') {
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof ios_js_1.IOSDriver) {
+            // iOS has no universal "back" concept — this is a no-op (same as maestro IOSDriver.backPress)
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            await driver.back(); // adb shell input keyevent 4
+        }
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)('back — done', opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`back — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/cheat-sheet.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cheatSheet = cheatSheet;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+async function cheatSheet() {
+    // Try to read SKILL.md from the package root
+    const skillPath = path_1.default.join(__dirname, '../../skills/conductor/SKILL.md');
+    try {
+        const content = await promises_1.default.readFile(skillPath, 'utf-8');
+        console.log(content);
+    }
+    catch {
+        // Fallback: print inline reference
+        console.log(INLINE_CHEAT_SHEET);
+    }
+    return 0;
+}
+const INLINE_CHEAT_SHEET = `
+conductor — Command Reference
+================================
+
+DEVICE MANAGEMENT
+  list-devices                              List connected devices/simulators
+  foreground-app                            Print bundle ID / package of the foreground app
+  list-apps                                 List installed app IDs / package names
+  session                                   Show current session (appId, deviceId)
+  session --clear                           Clear session state
+  session --list                            List all device sessions
+
+APP CONTROL
+  launch-app <appId> [--device <id>]        Launch app and save to session
+    --clear-state                           Wipe app data/state before launching
+    --clear-keychain                        Wipe keychain before launching
+    --argument key=value                    Set launch argument (repeatable)
+  stop-app [<appId>]                        Stop app (uses session appId if omitted)
+
+INTERACTIONS
+  tap <element>                             Tap element by text
+    --id <id>                               Match by accessibility ID instead of text
+    --index <n>                             Pick the nth match (0-based)
+    --long-press                            Hold instead of tap
+    --double-tap                            Double-tap the element
+  type <text>                               Type text into focused field
+  back                                      Press back button (Android only)
+  press-key <key>                           Press a key (Enter, Backspace, Home, ...)
+  scroll [--direction down|up|left|right]   Scroll (default: down)
+  swipe --direction <UP|DOWN|LEFT|RIGHT>    Directional swipe
+    --start <x,y>                           Start coordinate (0–1 normalised or absolute px)
+    --end <x,y>                             End coordinate (same)
+    --duration <ms>                         Swipe duration (default: 500)
+
+ASSERTIONS
+  assert-visible <element>                  Assert element is visible
+    --id <id>                               Match by accessibility ID instead of text
+    --timeout <ms>                          Max wait time (default: 17000)
+    --optional                              Succeed even if element is not found
+
+SCREENSHOTS & INSPECTION
+  screenshot [--output <path>]              Take screenshot (default: ./screenshot-<ts>.png)
+  inspect                                   Print UI hierarchy
+
+FLOW EXECUTION
+  run-flow <file> [--device <id>]           Run a Maestro YAML flow file
+  run-flow-inline <yaml>                    Run inline YAML commands
+
+DAEMON (optional — keeps driver alive between commands)
+  daemon-start [--device <id>]             Start background daemon
+  daemon-stop [--device <id>] [--all]      Stop daemon (--all stops every daemon)
+  daemon-status [--device <id>]            Show daemon status
+
+MULTI-AGENT / PARALLEL
+  device-pool --list                        List devices and pool status
+  device-pool --acquire                     Claim a free device (prints device ID)
+  device-pool --release <id>               Release a device back to the pool
+  run-parallel --flows-dir <path>           Run flows in parallel across all devices
+
+MISC
+  install --skills                          Install skill files into .claude/skills/
+  cheat-sheet                               Print this reference
+
+GLOBAL FLAGS
+  --device <id>                             Target device (auto-detected if omitted)
+  --json                                    Machine-readable JSON output
+  --verbose, -v                             Log daemon calls, fallbacks, raw output
+  --help, -h                                Show help
+
+EXAMPLES
+  conductor launch-app com.example.app
+  conductor tap "Sign In"
+  conductor tap --id "btn_login"
+  conductor type "hello@example.com"
+  conductor swipe --start 0.5,0.8 --end 0.5,0.2
+  conductor assert-visible "Dashboard" --timeout 30000
+  conductor screenshot --output /tmp/screen.png
+  conductor run-flow ./flows/login.yaml
+`.trim();

package/dist/commands/daemon.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.daemonStart = daemonStart;
+exports.daemonStop = daemonStop;
+exports.daemonStatusCmd = daemonStatusCmd;
+const client_js_1 = require("../daemon/client.js");
+const output_js_1 = require("../output.js");
+async function daemonStart(opts = {}, sessionName = 'default') {
+    const ready = await (0, client_js_1.startDaemon)(sessionName);
+    if (ready) {
+        (0, output_js_1.printSuccess)(`daemon [${sessionName}] started — driver process is running`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`daemon [${sessionName}] failed to start within timeout`, opts);
+        return 1;
+    }
+}
+async function daemonStop(opts = {}, sessionName = 'default', all = false) {
+    if (all) {
+        const sessions = (0, client_js_1.listDaemonSessions)();
+        if (sessions.length === 0) {
+            (0, output_js_1.printSuccess)('no daemons running', opts);
+            return 0;
+        }
+        let exitCode = 0;
+        for (const name of sessions) {
+            const stopped = await (0, client_js_1.stopDaemon)(name);
+            if (stopped) {
+                (0, output_js_1.printSuccess)(`daemon [${name}] stopped`, opts);
+            }
+            else {
+                (0, output_js_1.printError)(`daemon [${name}] was not running`, opts);
+                exitCode = 1;
+            }
+        }
+        return exitCode;
+    }
+    const stopped = await (0, client_js_1.stopDaemon)(sessionName);
+    if (stopped) {
+        (0, output_js_1.printSuccess)(`daemon [${sessionName}] stopped`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`daemon [${sessionName}] was not running`, opts);
+        return 1;
+    }
+}
+async function daemonStatusCmd(opts = {}, sessionName = 'default') {
+    const status = await (0, client_js_1.daemonStatus)(sessionName);
+    if (opts.json) {
+        (0, output_js_1.printData)({ ...status, sessionName }, opts);
+    }
+    else if (status.running) {
+        console.log(`daemon [${sessionName}]: running (pid ${status.pid ?? 'unknown'})`);
+    }
+    else {
+        console.log(`daemon [${sessionName}]: not running`);
+    }
+    return 0;
+}

package/dist/commands/device-pool.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devicePool = devicePool;
+/**
+ * device-pool: Manage a pool of available devices for concurrent multi-agent use.
+ *
+ * Pool state is stored in ~/.conductor/device-pool.json with file-based locking.
+ *
+ * Usage:
+ *   conductor device-pool --list             # list all devices and pool status
+ *   conductor device-pool --acquire          # claim a free device, print its ID
+ *   conductor device-pool --release <id>     # release a device back to the pool
+ */
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const output_js_1 = require("../output.js");
+const POOL_FILE = path_1.default.join(os_1.default.homedir(), '.conductor', 'device-pool.json');
+const LOCK_FILE = POOL_FILE + '.lock';
+const LOCK_TIMEOUT_MS = 5000;
+// ── File locking ──────────────────────────────────────────────────────────────
+async function withLock(fn) {
+    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        try {
+            const fd = fs_1.default.openSync(LOCK_FILE, 'wx'); // exclusive create
+            fs_1.default.closeSync(fd);
+            try {
+                return await Promise.resolve(fn());
+            }
+            finally {
+                try {
+                    fs_1.default.unlinkSync(LOCK_FILE);
+                }
+                catch {
+                    /* ok */
+                }
+            }
+        }
+        catch {
+            await sleep(50);
+        }
+    }
+    throw new Error('Could not acquire device pool lock');
+}
+function readPool() {
+    try {
+        const raw = fs_1.default.readFileSync(POOL_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { devices: [] };
+    }
+}
+function writePool(state) {
+    fs_1.default.mkdirSync(path_1.default.dirname(POOL_FILE), { recursive: true });
+    fs_1.default.writeFileSync(POOL_FILE, JSON.stringify(state, null, 2));
+}
+// ── Device discovery ──────────────────────────────────────────────────────────
+async function discoverAllDevices() {
+    const devices = [];
+    // Android: adb devices
+    try {
+        const out = await spawnCapture('adb', ['devices', '-l']);
+        for (const line of out.split('\n').slice(1)) {
+            const id = line.trim().split(/\s+/)[0];
+            if (id && !line.includes('offline') && id !== '') {
+                devices.push(id);
+            }
+        }
+    }
+    catch {
+        /* adb not available */
+    }
+    // iOS: xcrun simctl list booted
+    try {
+        const out = await spawnCapture('xcrun', ['simctl', 'list', 'devices', 'booted', '--json']);
+        const parsed = JSON.parse(out);
+        for (const sims of Object.values(parsed.devices)) {
+            for (const sim of sims) {
+                if (sim.state === 'Booted')
+                    devices.push(sim.udid);
+            }
+        }
+    }
+    catch {
+        /* xcrun not available */
+    }
+    return devices;
+}
+// ── Commands ──────────────────────────────────────────────────────────────────
+async function devicePool(action, releaseId, opts = {}) {
+    if (action === 'list') {
+        const allDevices = await discoverAllDevices();
+        const pool = readPool();
+        const rows = allDevices.map((id) => {
+            const entry = pool.devices.find((e) => e.deviceId === id);
+            const status = entry?.acquiredBy ? `acquired by PID ${entry.acquiredBy}` : 'free';
+            return `${id}  ${status}`;
+        });
+        if (opts.json) {
+            const data = allDevices.map((id) => {
+                const entry = pool.devices.find((e) => e.deviceId === id);
+                return { deviceId: id, free: !entry?.acquiredBy, acquiredBy: entry?.acquiredBy };
+            });
+            console.log(JSON.stringify({ status: 'ok', devices: data }));
+        }
+        else {
+            if (rows.length === 0) {
+                console.log('No devices found.');
+            }
+            else {
+                console.log(rows.join('\n'));
+            }
+        }
+        return 0;
+    }
+    if (action === 'acquire') {
+        const allDevices = await discoverAllDevices();
+        if (allDevices.length === 0) {
+            (0, output_js_1.printError)('No devices available', opts);
+            return 1;
+        }
+        const result = await withLock(() => {
+            const state = readPool();
+            // Prune stale acquisitions (process no longer running)
+            for (const entry of state.devices) {
+                if (entry.acquiredBy) {
+                    try {
+                        process.kill(parseInt(entry.acquiredBy, 10), 0);
+                    }
+                    catch {
+                        delete entry.acquiredBy;
+                        delete entry.acquiredAt;
+                    }
+                }
+            }
+            // Ensure all discovered devices are in the pool
+            for (const id of allDevices) {
+                if (!state.devices.find((e) => e.deviceId === id)) {
+                    state.devices.push({ deviceId: id });
+                }
+            }
+            // Find a free device
+            const free = state.devices.find((e) => allDevices.includes(e.deviceId) && !e.acquiredBy);
+            if (!free)
+                return null;
+            free.acquiredBy = String(process.pid);
+            free.acquiredAt = Date.now();
+            writePool(state);
+            return free.deviceId;
+        });
+        if (!result) {
+            (0, output_js_1.printError)('No free devices available in pool', opts);
+            return 1;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({ status: 'ok', deviceId: result }));
+        }
+        else {
+            console.log(result);
+        }
+        return 0;
+    }
+    if (action === 'release') {
+        if (!releaseId) {
+            (0, output_js_1.printError)('device-pool --release requires a device ID', opts);
+            return 1;
+        }
+        await withLock(() => {
+            const state = readPool();
+            const entry = state.devices.find((e) => e.deviceId === releaseId);
+            if (entry) {
+                delete entry.acquiredBy;
+                delete entry.acquiredAt;
+                writePool(state);
+            }
+        });
+        (0, output_js_1.printSuccess)(`Released device ${releaseId}`, opts);
+        return 0;
+    }
+    (0, output_js_1.printError)('device-pool: unknown action', opts);
+    return 1;
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function spawnCapture(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(cmd, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        let out = '';
+        proc.stdout?.on('data', (chunk) => {
+            out += chunk.toString();
+        });
+        proc.on('close', (code) => code === 0 ? resolve(out) : reject(new Error(`${cmd} failed (${code})`)));
+        proc.on('error', reject);
+    });
+}

package/dist/commands/erase-text.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eraseText = eraseText;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+async function eraseText(characters, opts = {}, sessionName = 'default') {
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof android_js_1.AndroidDriver) {
+            await driver.eraseAllText(characters);
+        }
+        else if (driver instanceof ios_js_1.IOSDriver) {
+            for (let i = 0; i < characters; i++)
+                await driver.pressKey('delete');
+        }
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`erase-text ${characters} — done`, opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`erase-text ${characters} — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}

package/dist/commands/foreground-app.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foregroundApp = foregroundApp;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+async function resolveDeviceId(sessionName) {
+    if (sessionName !== 'default')
+        return sessionName;
+    return (0, runner_js_1.detectFirstDevice)();
+}
+async function getInstalledAppIds(deviceId) {
+    const result = await (0, runner_js_1.spawnCommand)('bash', [
+        '-c',
+        `xcrun simctl listapps ${deviceId} | plutil -convert json - -o -`,
+    ]);
+    if (!result.success)
+        return [];
+    try {
+        return Object.keys(JSON.parse(result.stdout));
+    }
+    catch {
+        return [];
+    }
+}
+async function foregroundApp(opts = {}, sessionName = 'default') {
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        let appId;
+        if (driver instanceof ios_js_1.IOSDriver) {
+            const deviceId = await resolveDeviceId(sessionName);
+            const appIds = deviceId ? await getInstalledAppIds(deviceId) : [];
+            appId = await driver.runningApp(appIds);
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            appId = await driver.getForegroundApp();
+        }
+        else {
+            throw new Error('Unsupported driver');
+        }
+        (0, output_js_1.printSuccess)(appId, opts);
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        (0, output_js_1.printError)(`foreground-app failed\n${msg}`, opts);
+        return 1;
+    }
+}

package/dist/commands/hide-keyboard.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hideKeyboard = hideKeyboard;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+async function hideKeyboard(opts = {}, sessionName = 'default') {
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof ios_js_1.IOSDriver) {
+            await driver.pressKey('return').catch(() => {
+                /* no keyboard visible */
+            });
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            await driver.pressKeyEvent(111); // KEYCODE_ESCAPE
+        }
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)('hide-keyboard — done', opts);
+        return 0;
+    }
+    else {
+        (0, output_js_1.printError)(`hide-keyboard — failed\n${result.stderr}`, opts);
+        return 1;
+    }
+}