@houwert/conductor 0.21.0 → 0.23.0

package/dist/drivers/ios.js

@@ -160,8 +160,11 @@ class IOSDriver {
         await this.post('pressKey', { key });
         this.invalidateHierarchyCache();
     }
-    async pressButton(button) {
-        await this.post('pressButton', { button });
+    async pressButton(button, duration) {
+        await this.post('pressButton', {
+            button,
+            ...(duration !== undefined ? { duration } : {}),
+        });
         this.invalidateHierarchyCache();
     }
     async launchApp(bundleId, args) {

package/dist/drivers/log-sources/metro-discovery.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isMetroPort = isMetroPort;
 exports.discoverMetroPortForDevice = discoverMetroPortForDevice;
 exports.getDeviceDisplayName = getDeviceDisplayName;
+exports.deviceNameMatches = deviceNameMatches;
 exports.selectTargetForDevice = selectTargetForDevice;
 exports.targetsForDevice = targetsForDevice;
 /**
@@ -25,6 +26,10 @@ exports.targetsForDevice = targetsForDevice;
 const child_process_1 = require("child_process");
 const metro_js_1 = require("./metro.js");
 const sdk_js_1 = require("../../android/sdk.js");
+const cli_js_1 = require("../vega/cli.js");
+// Standard Metro dev-server ports to probe for the Vega VVD, which — unlike
+// iOS/Android — exposes no host-visible socket mapping we can read.
+const VEGA_METRO_CANDIDATE_PORTS = [8081, 8082];
 /**
  * Heuristic to reject ports that obviously aren't a Metro dev server (system
  * ports, well-known services). Candidates that pass are always verified via
@@ -61,6 +66,33 @@ async function discoverMetroPortForDevice(platform, deviceId) {
     if (platform === 'ios' || platform === 'tvos') {
         return discoverMetroPortIOS(deviceId);
     }
+    if (platform === 'vega') {
+        return discoverMetroPortVega(deviceId);
+    }
+    return null;
+}
+/**
+ * Locate the Metro port for a Vega VVD. There is no host-visible socket mapping,
+ * so probe the standard Metro ports and accept the first that is a real Metro
+ * server hosting a target for this device (matched by display name when known).
+ */
+async function discoverMetroPortVega(deviceId) {
+    const displayName = await getDeviceDisplayName('vega', deviceId);
+    for (const port of VEGA_METRO_CANDIDATE_PORTS) {
+        try {
+            const targets = await (0, metro_js_1.fetchTargets)(port, 'localhost');
+            if (targets.length === 0)
+                continue;
+            // Prefer a name match; fall back to any target (single-device v1).
+            if (!displayName || targets.some((t) => deviceNameMatches(t.deviceName, displayName))) {
+                return port;
+            }
+            return port;
+        }
+        catch {
+            // not Metro on this port — try the next
+        }
+    }
     return null;
 }
 async function discoverMetroPortAndroid(deviceId) {
@@ -198,8 +230,30 @@ async function getDeviceDisplayName(platform, deviceId) {
             return null;
         }
     }
+    if (platform === 'vega') {
+        // deviceId is `vega:<serial>`; resolve the VVD's reported description.
+        const serial = deviceId.replace(/^vega:/, '');
+        try {
+            const devices = await new cli_js_1.VegaCli().listDevices();
+            const match = devices.find((d) => d.serial === serial);
+            return match?.description ?? serial;
+        }
+        catch {
+            return serial;
+        }
+    }
     return null;
 }
+/**
+ * Whether a Metro target's `deviceName` refers to the same device as `displayName`.
+ * Tolerant of the suffixes Metro appends to the bare model name — e.g. Android's
+ * `ro.product.model` is `Chromecast` while Metro reports `Chromecast - 14 - API 34`.
+ */
+function deviceNameMatches(targetDeviceName, displayName) {
+    if (!targetDeviceName)
+        return false;
+    return targetDeviceName === displayName || targetDeviceName.startsWith(`${displayName} `);
+}
 /**
  * Filter Metro /json targets to those belonging to this device (by display
  * name), preferring the fusebox runtime if present. Returns undefined when
@@ -208,7 +262,7 @@ async function getDeviceDisplayName(platform, deviceId) {
  */
 function selectTargetForDevice(targets, displayName) {
     const withWs = targets.filter((t) => t.webSocketDebuggerUrl);
-    const matches = withWs.filter((t) => t.deviceName === displayName);
+    const matches = withWs.filter((t) => deviceNameMatches(t.deviceName, displayName));
     if (matches.length === 0)
         return undefined;
     const fusebox = matches.find((t) => t.reactNative?.capabilities?.prefersFuseboxFrontend);
@@ -216,5 +270,5 @@ function selectTargetForDevice(targets, displayName) {
 }
 /** Convenience: all /json targets belonging to this device. */
 function targetsForDevice(targets, displayName) {
-    return targets.filter((t) => t.webSocketDebuggerUrl && t.deviceName === displayName);
+    return targets.filter((t) => t.webSocketDebuggerUrl && deviceNameMatches(t.deviceName, displayName));
 }

package/dist/drivers/log-sources/vega.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VegaLogSource = void 0;
+const cli_js_1 = require("../vega/cli.js");
+/** Map a Vega/Android-style level token to a LogEntry level. */
+function mapLevel(token) {
+    switch (token.toUpperCase()) {
+        case 'V':
+        case 'VERBOSE':
+            return 'verbose';
+        case 'D':
+        case 'DEBUG':
+            return 'debug';
+        case 'I':
+        case 'INFO':
+            return 'info';
+        case 'W':
+        case 'WARN':
+        case 'WARNING':
+            return 'warning';
+        case 'E':
+        case 'ERROR':
+        case 'F':
+        case 'FATAL':
+            return 'error';
+        default:
+            return 'log';
+    }
+}
+class VegaLogSource {
+    constructor(serial) {
+        this.serial = serial;
+        this.proc = null;
+        this.callback = null;
+        this.buffer = '';
+    }
+    async connect() {
+        this.proc = new cli_js_1.VegaCli(this.serial).startLogStream();
+        const onData = (chunk) => {
+            this.buffer += chunk.toString('utf-8');
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (line.trim())
+                    this.emit(line);
+            }
+        };
+        this.proc.stdout?.on('data', onData);
+        this.proc.stderr?.on('data', onData);
+        this.proc.on('error', () => {
+            /* vega CLI not available — no logs */
+        });
+    }
+    onEntry(callback) {
+        this.callback = callback;
+    }
+    disconnect() {
+        if (this.proc) {
+            this.proc.kill('SIGTERM');
+            this.proc = null;
+        }
+    }
+    emit(line) {
+        // Best-effort level extraction from a leading/embedded level token; the raw
+        // line is always preserved as the message.
+        const levelMatch = /\b([VDIWEF]|VERBOSE|DEBUG|INFO|WARN(?:ING)?|ERROR|FATAL)\b/.exec(line);
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level: levelMatch ? mapLevel(levelMatch[1]) : 'log',
+            message: line,
+            stackTrace: null,
+            source: 'device',
+        };
+        this.callback?.(entry);
+    }
+}
+exports.VegaLogSource = VegaLogSource;

package/dist/drivers/metro-cdp.js

@@ -40,12 +40,20 @@ function selectDebuggerUrl(targets, opts, displayName) {
         }
         return withWs[opts.targetIndex].webSocketDebuggerUrl;
     }
-    if (displayName) {
-        const target = (0, metro_discovery_js_1.selectTargetForDevice)(withWs, displayName);
+    // Device-scoped: must resolve to that device's own target. Never silently
+    // fall back to another device — that reloads the wrong app and reports success.
+    if (opts.deviceId) {
+        const target = displayName ? (0, metro_discovery_js_1.selectTargetForDevice)(withWs, displayName) : undefined;
         if (target)
             return target.webSocketDebuggerUrl;
+        const available = withWs
+            .map((t, i) => `  [${i}] ${t.deviceName ?? t.title ?? '(unnamed)'}`)
+            .join('\n');
+        throw new Error(`No Metro debugger target for device ${opts.deviceId}` +
+            (displayName ? ` (${displayName})` : '') +
+            `.\nAvailable targets:\n${available}\nPass --target <index> to pick one explicitly.`);
     }
-    // Prefer the Hermes/React target by title, otherwise first.
+    // No device requested: prefer the Hermes/React target by title, otherwise first.
     const target = withWs.find((t) => t.title && /hermes|react/i.test(t.title)) ?? withWs[0];
     return target.webSocketDebuggerUrl;
 }

package/dist/drivers/vega/automation-client.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VegaAutomationClient = exports.VegaToolkitUnavailableError = void 0;
+/**
+ * Talks to the on-device automation toolkit (the accessibility server Amazon's
+ * Appium Vega driver uses), which serves JSON-RPC on device TCP port 8383.
+ *
+ * Vega is not adb, so there is no host-side `adb forward`. Instead we run `curl`
+ * on the device (`vega … run-cmd`), writing the JSON-RPC response to a device file
+ * with `curl -o` and pulling it to the host with `copy-from`. Routing through a
+ * file (rather than the command's stdout) is required: `run-cmd` truncates large
+ * stdout — a full-screen screenshot PNG and a deep page-source tree both exceed it.
+ */
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const TOOLKIT_PORT = 8383;
+class VegaToolkitUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'VegaToolkitUnavailableError';
+    }
+}
+exports.VegaToolkitUnavailableError = VegaToolkitUnavailableError;
+class VegaAutomationClient {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    /** Current screen's page-source XML. */
+    async getPageSource() {
+        const result = await this.call('getPageSource');
+        return typeof result === 'string' ? result : JSON.stringify(result);
+    }
+    /** Current screen as PNG bytes (base64 in the RPC result). */
+    async getScreenshot() {
+        const result = await this.call('takeScreenshot');
+        if (typeof result !== 'string') {
+            throw new VegaToolkitUnavailableError('takeScreenshot returned no image data');
+        }
+        return Buffer.from(result, 'base64');
+    }
+    /** POST a parameterless JSON-RPC [method] to the toolkit and return its `result`. */
+    async call(method) {
+        const devicePath = `/tmp/conductor-vega-${method}.json`;
+        const payload = `{"jsonrpc":"2.0","id":1,"method":"${method}","params":{}}`;
+        await this.connection.shell(`curl -s -X POST -H 'Content-Type: application/json' -d '${payload}' ` +
+            `-o ${devicePath} http://127.0.0.1:${TOOLKIT_PORT}/jsonrpc`);
+        const hostFile = path_1.default.join(os_1.default.tmpdir(), `conductor-vega-${method}-${process.pid}-${TOOLKIT_PORT}.json`);
+        try {
+            await this.connection.copyFrom(devicePath, hostFile);
+            const raw = await promises_1.default.readFile(hostFile, 'utf-8').catch(() => '');
+            if (!raw) {
+                throw new VegaToolkitUnavailableError(`Empty response from the Vega automation toolkit (method=${method}). The toolkit ` +
+                    `attaches at app launch after the enable flag is set — relaunch the app under test.`);
+            }
+            let node;
+            try {
+                node = JSON.parse(raw);
+            }
+            catch {
+                throw new VegaToolkitUnavailableError(`Malformed toolkit response for ${method}`);
+            }
+            if (node.error !== undefined && node.error !== null) {
+                throw new VegaToolkitUnavailableError(`Toolkit error for ${method}: ${JSON.stringify(node.error)}`);
+            }
+            if (node.result === undefined) {
+                throw new VegaToolkitUnavailableError(`Toolkit response for ${method} had no result`);
+            }
+            return node.result;
+        }
+        finally {
+            await promises_1.default.rm(hostFile, { force: true }).catch(() => { });
+        }
+    }
+}
+exports.VegaAutomationClient = VegaAutomationClient;

package/dist/drivers/vega/cli.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VegaCli = void 0;
+exports.commandSucceeded = commandSucceeded;
+exports.commandOutput = commandOutput;
+/**
+ * Thin wrapper over Amazon's Vega developer CLI. Vega is not Android, so we drive
+ * it through the SDK's own binary (`vega`/`kepler`/`vda`) rather than adb — this is
+ * the only supported channel and keeps the same path working for physical Fire TVs.
+ *
+ * Command surface (verified against the Vega SDK via Maestro's reference driver):
+ *  - `vega device list` prints one `<selector> : <profile> - <arch> - <os> - <host>`
+ *    line per device; the `-d` selector is the first field (e.g. `VirtualDevice`).
+ *  - on-device commands run via `vega device run-cmd -d <sel> -c '<cmd>'` (there is
+ *    no `shell -c`; plain `shell` is interactive).
+ *  - `-d` is a per-subcommand option, so it follows the subcommand name.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const verbose_js_1 = require("../../verbose.js");
+function commandSucceeded(r) {
+    return r.exitCode === 0;
+}
+function commandOutput(r) {
+    return `${r.stdout}\n${r.stderr}`.trim();
+}
+let _resolvedBinary = null;
+class VegaCli {
+    constructor(serial, binary) {
+        this.serial = serial;
+        this.binary = binary ?? VegaCli.resolveBinary();
+    }
+    /** Run a raw CLI invocation and capture output. */
+    exec(args, timeoutSeconds = 120) {
+        (0, verbose_js_1.log)(`vega cli: ${this.binary} ${args.join(' ')}`);
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)(this.binary, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+            let stdout = '';
+            let stderr = '';
+            const timer = setTimeout(() => {
+                proc.kill('SIGKILL');
+            }, timeoutSeconds * 1000);
+            proc.stdout.on('data', (c) => {
+                stdout += c.toString();
+            });
+            proc.stderr.on('data', (c) => {
+                stderr += c.toString();
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timer);
+                resolve({ exitCode: code ?? 1, stdout, stderr });
+            });
+            proc.on('error', (err) => {
+                clearTimeout(timer);
+                resolve({ exitCode: 127, stdout: '', stderr: err.message });
+            });
+        });
+    }
+    /** Build `device <subcommand> [-d serial] <rest…>` — `-d` follows the subcommand. */
+    deviceArgs(subcommand, ...rest) {
+        const selector = this.serial ? ['-d', this.serial] : [];
+        return ['device', subcommand, ...selector, ...rest];
+    }
+    deviceExec(subcommand, rest = [], timeoutSeconds = 120) {
+        return this.exec(this.deviceArgs(subcommand, ...rest), timeoutSeconds);
+    }
+    async listDevices() {
+        const result = await this.exec(['device', 'list']);
+        if (!commandSucceeded(result)) {
+            (0, verbose_js_1.log)(`\`vega device list\` failed: ${commandOutput(result)}`);
+            return [];
+        }
+        return VegaCli.parseDeviceList(result.stdout);
+    }
+    /** Run a shell command on the device and return its stdout (via `run-cmd -c`). */
+    async shell(command) {
+        const result = await this.deviceExec('run-cmd', ['-c', command]);
+        if (!commandSucceeded(result)) {
+            throw new Error(`Vega run-cmd failed: ${commandOutput(result)}`);
+        }
+        return result.stdout;
+    }
+    /** Copy a device file to the host via `copy-from` (a file transfer, no stdout limit). */
+    async copyFrom(remotePath, localPath) {
+        const result = await this.deviceExec('copy-from', ['-s', remotePath, '-o', localPath]);
+        if (!commandSucceeded(result)) {
+            throw new Error(`Failed to copy ${remotePath} from device: ${commandOutput(result)}`);
+        }
+    }
+    async launchApp(appId) {
+        const result = await this.deviceExec('launch-app', ['-a', appId]);
+        if (!commandSucceeded(result)) {
+            throw new Error(`Failed to launch ${appId}: ${commandOutput(result)}`);
+        }
+    }
+    async terminateApp(appId) {
+        const result = await this.deviceExec('terminate-app', ['-a', appId]);
+        if (!commandSucceeded(result)) {
+            (0, verbose_js_1.log)(`Failed to terminate ${appId}: ${commandOutput(result)}`);
+        }
+    }
+    async installApp(vpkgPath) {
+        const result = await this.deviceExec('install-app', ['-p', vpkgPath], 300);
+        if (!commandSucceeded(result)) {
+            throw new Error(`Failed to install ${vpkgPath}: ${commandOutput(result)}`);
+        }
+    }
+    async listInstalledApps() {
+        const result = await this.deviceExec('installed-apps');
+        if (!commandSucceeded(result))
+            return [];
+        return result.stdout
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && l.includes('.') && !l.includes(' '));
+    }
+    /** Start streaming device logs with stdout/stderr piped; caller owns the process. */
+    startLogStream() {
+        return (0, child_process_1.spawn)(this.binary, this.deviceArgs('start-log-stream'), {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    /**
+     * Boot a Vega Virtual Device via `vega virtual-device start [<name>]`, detached
+     * like the Android emulator — the process runs the VVD in the background and the
+     * caller polls {@link listDevices} for readiness. Returns the spawned process.
+     */
+    spawnVirtualDeviceStart(name) {
+        const args = ['virtual-device', 'start', ...(name ? [name] : [])];
+        const proc = (0, child_process_1.spawn)(this.binary, args, { detached: true, stdio: 'ignore' });
+        proc.unref();
+        return proc;
+    }
+    // Device lines look like: `VirtualDevice : tv - aarch64 - OS - amazon-<hostname>`.
+    // The `-d` selector is the first field (before " : "), not the trailing hostname.
+    static parseDeviceList(output) {
+        return output
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l.includes(' : '))
+            .map((line) => {
+            const serial = line.slice(0, line.indexOf(' : ')).trim();
+            if (!serial)
+                return null;
+            const isVirtual = /^virtualdevice$/i.test(serial) || /^simulator$/i.test(serial) || /virtual/i.test(line);
+            return { serial, description: line, isVirtual };
+        })
+            .filter((d) => d !== null);
+    }
+    /** Resolve the Vega CLI binary: env override → PATH probe → ~/vega/bin → `vega`. */
+    static resolveBinary() {
+        if (_resolvedBinary)
+            return _resolvedBinary;
+        const envOverride = process.env.CONDUCTOR_VEGA_CLI;
+        if (envOverride && envOverride.trim()) {
+            _resolvedBinary = envOverride.trim();
+            return _resolvedBinary;
+        }
+        const candidates = ['vega', 'kepler', 'vda'];
+        for (const candidate of candidates) {
+            if (isOnPath(candidate)) {
+                _resolvedBinary = candidate;
+                return candidate;
+            }
+        }
+        const binDir = path_1.default.join(os_1.default.homedir(), 'vega', 'bin');
+        for (const candidate of candidates) {
+            const full = path_1.default.join(binDir, candidate);
+            if (fs_1.default.existsSync(full)) {
+                _resolvedBinary = full;
+                return full;
+            }
+        }
+        // Fall back to `vega`; the first invocation surfaces a clear "command not found".
+        _resolvedBinary = 'vega';
+        return _resolvedBinary;
+    }
+}
+exports.VegaCli = VegaCli;
+function isOnPath(command) {
+    const dirs = (process.env.PATH ?? '').split(path_1.default.delimiter);
+    for (const dir of dirs) {
+        if (!dir)
+            continue;
+        try {
+            fs_1.default.accessSync(path_1.default.join(dir, command), fs_1.default.constants.X_OK);
+            return true;
+        }
+        catch {
+            /* not here */
+        }
+    }
+    return false;
+}

package/dist/drivers/vega/connection.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VegaDeviceConnection = void 0;
+/**
+ * On-device operations for a single Vega target, all routed through {@link VegaCli}.
+ *
+ * The automation toolkit that serves the view hierarchy (device port 8383) only
+ * attaches when the flag file exists *at app launch*, so {@link ensureToolkitEnabled}
+ * must be called before launching the app under test.
+ */
+const cli_js_1 = require("./cli.js");
+const verbose_js_1 = require("../../verbose.js");
+const TOOLKIT_ENABLE_FLAG = '/tmp/automation-toolkit.enable';
+const SCREEN_SIZE_RE = /(\d+)\s*x\s*(\d+)/;
+class VegaDeviceConnection {
+    constructor(serial, cli = new cli_js_1.VegaCli(serial)) {
+        this.serial = serial;
+        this.cli = cli;
+    }
+    shell(command) {
+        return this.cli.shell(command);
+    }
+    copyFrom(remotePath, localPath) {
+        return this.cli.copyFrom(remotePath, localPath);
+    }
+    /** Idempotently create the toolkit enable flag (read at app launch). */
+    async ensureToolkitEnabled() {
+        try {
+            await this.shell(`touch ${TOOLKIT_ENABLE_FLAG}`);
+        }
+        catch (err) {
+            (0, verbose_js_1.log)(`Failed to enable Vega automation toolkit flag: ${String(err)}`);
+        }
+    }
+    /**
+     * Device screen size via `inputd-cli get_screen_size`. This is also the
+     * developer-mode gate: with dev mode off the on-device shell service is down
+     * and no "<W> x <H>" prints.
+     */
+    async screenSize() {
+        const out = (await this.shell('inputd-cli get_screen_size')).trim();
+        const match = SCREEN_SIZE_RE.exec(out);
+        if (!match)
+            return null;
+        return { width: parseInt(match[1], 10), height: parseInt(match[2], 10) };
+    }
+}
+exports.VegaDeviceConnection = VegaDeviceConnection;

package/dist/drivers/vega/input.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VegaInput = exports.VegaInputUnavailableError = exports.VEGA_BUTTON_KEYS = void 0;
+exports.shellQuote = shellQuote;
+const SETTLE_MS = 300;
+const LONG_PRESS_MS = 1000;
+// Verified key names (via Maestro): select is KEY_ENTER (KEY_SELECT is a no-op),
+// home is KEY_HOMEPAGE (KEY_HOME is inert), back is KEY_BACK.
+exports.VEGA_BUTTON_KEYS = {
+    up: 'KEY_UP',
+    down: 'KEY_DOWN',
+    left: 'KEY_LEFT',
+    right: 'KEY_RIGHT',
+    select: 'KEY_ENTER',
+    menu: 'KEY_MENU',
+    home: 'KEY_HOMEPAGE',
+    back: 'KEY_BACK',
+    playPause: 'KEY_PLAYPAUSE',
+    rewind: 'KEY_REWIND',
+    fastForward: 'KEY_FASTFORWARD',
+    volumeUp: 'KEY_VOLUMEUP',
+    volumeDown: 'KEY_VOLUMEDOWN',
+};
+class VegaInputUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'VegaInputUnavailableError';
+    }
+}
+exports.VegaInputUnavailableError = VegaInputUnavailableError;
+class VegaInput {
+    constructor(connection) {
+        this.connection = connection;
+        this.inputChecked = false;
+    }
+    /** Probe the input channel once; raises an actionable error if dev mode is off. */
+    async ensureInputAvailable() {
+        if (this.inputChecked)
+            return;
+        const size = await this.connection.screenSize().catch(() => null);
+        if (!size) {
+            throw new VegaInputUnavailableError('Vega input is unavailable: `inputd-cli` could not be reached over the device shell, ' +
+                "which means the VVD's developer mode is off. Enable it (`vsm developer-mode enable`, " +
+                'e.g. via `vega device shell`) and retry.');
+        }
+        this.inputChecked = true;
+    }
+    async pressButton(button) {
+        const keyName = exports.VEGA_BUTTON_KEYS[button];
+        if (!keyName)
+            throw new Error(`Button "${button}" is not supported on Vega`);
+        await this.buttonPress(keyName);
+    }
+    async buttonPress(keyName) {
+        await this.ensureInputAvailable();
+        await this.connection.shell(`inputd-cli button_press ${keyName}`);
+        await settle();
+    }
+    async tap(x, y) {
+        await this.ensureInputAvailable();
+        await this.connection.shell(`inputd-cli touch ${Math.round(x)} ${Math.round(y)}`);
+        await settle();
+    }
+    async longPress(x, y) {
+        await this.ensureInputAvailable();
+        // Vega expresses a long press via the hold duration on a touch.
+        await this.connection.shell(`inputd-cli touch ${Math.round(x)} ${Math.round(y)} --holdDuration ${LONG_PRESS_MS}`);
+        await settle();
+    }
+    async swipe(startX, startY, endX, endY, durationMs) {
+        await this.ensureInputAvailable();
+        await this.connection.shell(`inputd-cli swipe ${Math.round(startX)} ${Math.round(startY)} ` +
+            `${Math.round(endX)} ${Math.round(endY)} --interval ${Math.round(durationMs)}`);
+        await settle();
+    }
+    async inputText(text) {
+        if (text.includes('\n') || text.includes('\r')) {
+            throw new Error('Vega keyboard text must not contain newlines');
+        }
+        await this.ensureInputAvailable();
+        await this.connection.shell(`inputd-cli send_text ${shellQuote(text)}`);
+        await settle();
+    }
+    async eraseText(charactersToErase) {
+        await this.ensureInputAvailable();
+        for (let i = 0; i < charactersToErase; i++) {
+            await this.connection.shell('inputd-cli button_press KEY_BACKSPACE');
+        }
+        await settle();
+    }
+}
+exports.VegaInput = VegaInput;
+function settle() {
+    // Give the focus engine time to keep up (CI's software renderer is slow).
+    return new Promise((r) => setTimeout(r, SETTLE_MS));
+}
+/** Single-quote a string for a POSIX device shell, escaping embedded quotes. */
+function shellQuote(value) {
+    return "'" + value.replace(/'/g, "'\\''") + "'";
+}