@autifyhq/aximo-cli 0.3.0 → 0.5.0

package/dist/mobile-control/devices.js

@@ -0,0 +1,99 @@
+import { execBinary } from "./exec.js";
+/** Parse `adb devices -l` into serial + state (+ model when present). */
+export async function listAndroidDevices(exec = execBinary) {
+    const { stdout } = await exec("adb", ["devices", "-l"]);
+    const lines = stdout.toString("utf-8").split("\n").slice(1);
+    const result = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        const parts = line.split(/\s+/);
+        const serial = parts[0];
+        const state = parts[1];
+        if (!serial || !state)
+            continue;
+        const modelToken = parts.find((p) => p.startsWith("model:"));
+        const device = { serial, state };
+        if (modelToken)
+            device.model = modelToken.slice("model:".length);
+        result.push(device);
+    }
+    return result;
+}
+/** Resolve an adb serial: explicit (validated), else the single connected phone. */
+export async function resolveAndroidSerial(preferred, exec = execBinary) {
+    const devices = await listAndroidDevices(exec);
+    if (preferred) {
+        if (preferred.startsWith("emulator-")) {
+            throw new Error("Emulators are not supported — register a physical phone connected over USB only.");
+        }
+        const match = devices.find((d) => d.serial === preferred);
+        if (!match) {
+            throw new Error(`No Android device with serial '${preferred}' is connected.`);
+        }
+        if (match.state === "unauthorized") {
+            throw new Error("Android device is unauthorized. Accept the RSA prompt on the device, then retry.");
+        }
+        if (match.state === "offline") {
+            throw new Error("Android device is offline — reconnect the USB cable and unlock the phone.");
+        }
+        if (match.state !== "device") {
+            throw new Error(`Android device '${preferred}' is in state '${match.state}' — reconnect and unlock the phone.`);
+        }
+        return match.serial;
+    }
+    // Physical phones only: exclude emulator serials (mirrors list.ts).
+    const usable = devices.filter((d) => d.state === "device" && !d.serial.startsWith("emulator-"));
+    if (usable.length === 1 && usable[0])
+        return usable[0].serial;
+    if (usable.length === 0) {
+        const unauthorized = devices.find((d) => d.state === "unauthorized");
+        if (unauthorized) {
+            throw new Error("Android device is unauthorized. Accept the RSA prompt on the device, then retry.");
+        }
+        const offline = devices.find((d) => d.state === "offline");
+        if (offline) {
+            throw new Error("Android device is offline — reconnect the USB cable and unlock the phone.");
+        }
+        throw new Error("No connected Android devices found. Connect a phone over USB.");
+    }
+    throw new Error(`Multiple Android devices found; pass --serial. Available: ${usable
+        .map((d) => d.serial)
+        .join(", ")}`);
+}
+/**
+ * List physically-connected iOS devices via `idb list-targets --json` (one JSON
+ * object per line). Only entries whose `type` is `device` are returned. Returns
+ * an empty list if idb is unavailable.
+ */
+export async function listIosPhysicalDevices(exec = execBinary) {
+    let stdout;
+    try {
+        ({ stdout } = await exec("idb", ["list-targets", "--json"]));
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    for (const line of stdout.toString("utf-8").split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const entry = JSON.parse(trimmed);
+            if (entry.type === "device" &&
+                typeof entry.udid === "string" &&
+                typeof entry.name === "string") {
+                const device = { udid: entry.udid, name: entry.name };
+                if (typeof entry.state === "string")
+                    device.state = entry.state;
+                result.push(device);
+            }
+        }
+        catch {
+            // ignore non-JSON lines
+        }
+    }
+    return result;
+}

package/dist/mobile-control/devices.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mobile-control/devices.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { listAndroidDevices, resolveAndroidSerial } from "./devices.js";
+function fixed(stdout) {
+    return async () => ({ stdout: Buffer.from(stdout), stderr: "" });
+}
+describe("listAndroidDevices / resolveAndroidSerial", () => {
+    it("parses adb devices -l output", async () => {
+        const exec = fixed("List of devices attached\nR1 device model:Pixel_7\nR2 unauthorized\n");
+        const devices = await listAndroidDevices(exec);
+        expect(devices).toEqual([
+            { serial: "R1", state: "device", model: "Pixel_7" },
+            { serial: "R2", state: "unauthorized" },
+        ]);
+    });
+    it("auto-selects the only online device", async () => {
+        const exec = fixed("List of devices attached\nR1 device\n");
+        await expect(resolveAndroidSerial(undefined, exec)).resolves.toBe("R1");
+    });
+    it("reports an actionable error for an unauthorized-only device", async () => {
+        const exec = fixed("List of devices attached\nR1 unauthorized\n");
+        await expect(resolveAndroidSerial(undefined, exec)).rejects.toThrow(/unauthorized/i);
+    });
+    it("rejects an explicitly-passed emulator serial", async () => {
+        const exec = fixed("List of devices attached\nemulator-5554 device\n");
+        await expect(resolveAndroidSerial("emulator-5554", exec)).rejects.toThrow(/emulator/i);
+    });
+    it("rejects an explicitly-passed unauthorized device", async () => {
+        const exec = fixed("List of devices attached\nR1 unauthorized\n");
+        await expect(resolveAndroidSerial("R1", exec)).rejects.toThrow(/unauthorized/i);
+    });
+    it("rejects an explicitly-passed offline device", async () => {
+        const exec = fixed("List of devices attached\nR1 offline\n");
+        await expect(resolveAndroidSerial("R1", exec)).rejects.toThrow(/offline/i);
+    });
+});

package/dist/mobile-control/exec.d.ts

@@ -0,0 +1,6 @@
+export interface ExecResult {
+    stdout: Buffer;
+    stderr: string;
+}
+export type ExecFn = (file: string, args: string[]) => Promise<ExecResult>;
+export declare const execBinary: ExecFn;

package/dist/mobile-control/exec.js

@@ -0,0 +1,13 @@
+import { execFile } from "node:child_process";
+// Explicit argv, no shell — payloads can't inject into the local machine.
+export const execBinary = (file, args) => new Promise((resolve, reject) => {
+    execFile(file, args, { encoding: "buffer", maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+        const stderrText = stderr.toString("utf-8");
+        if (error) {
+            const message = stderrText.trim() || error.message;
+            reject(new Error(`${file} ${args.join(" ")} failed: ${message}`));
+            return;
+        }
+        resolve({ stdout, stderr: stderrText });
+    });
+});

package/dist/mobile-control/tunnel.d.ts

@@ -0,0 +1,11 @@
+import { type Socket } from "socket.io-client";
+import type { MobileController } from "./controller.js";
+export interface RunControlTunnelOptions {
+    wsUrl: string;
+    deviceToken: string;
+    deviceName: string;
+    controller: MobileController;
+    connect?: (wsUrl: string, deviceToken: string) => Socket;
+}
+export declare function registerHandlers(socket: Socket, controller: MobileController): void;
+export declare function runControlTunnel(options: RunControlTunnelOptions): Promise<void>;

package/dist/mobile-control/tunnel.js

@@ -0,0 +1,152 @@
+import { io } from "socket.io-client";
+const SOCKET_PATH = "/devices/tunnel";
+function ok() {
+    return { ok: true };
+}
+function fail(error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+}
+function asActionResult(result) {
+    if (result.ok)
+        return { ok: true };
+    return result.error !== undefined ? { ok: false, error: result.error } : { ok: false };
+}
+function num(value, fallback = 0) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+/** Required numeric arg: returns the finite number, or null when missing/non-finite. */
+function reqNum(args, key) {
+    const value = args[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function requireCoords(args, keys) {
+    const coords = [];
+    for (const key of keys) {
+        const value = reqNum(args, key);
+        if (value === null)
+            return { error: "requires numeric coordinates" };
+        coords.push(value);
+    }
+    return { coords };
+}
+function humanizeDateTime(date) {
+    return date.toLocaleString("en-US", {
+        weekday: "long",
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true,
+    });
+}
+function defaultConnect(wsUrl, deviceToken) {
+    return io(wsUrl, {
+        path: SOCKET_PATH,
+        transports: ["websocket"],
+        auth: { deviceToken },
+        reconnectionAttempts: 10,
+        timeout: 10000,
+    });
+}
+export function registerHandlers(socket, controller) {
+    const on = (event, handler) => {
+        socket.on(event, (rawArgs, ack) => {
+            const args = (rawArgs ?? {});
+            void handler(args)
+                .then((result) => ack?.(result))
+                .catch((err) => ack?.(fail(err)));
+        });
+    };
+    on("ping", async () => ok());
+    on("screenshot", async () => controller.screenshot());
+    on("datetime", async () => {
+        const fromDevice = await controller.getDeviceTime?.();
+        if (fromDevice)
+            return fromDevice;
+        return {
+            datetime: humanizeDateTime(new Date()),
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        };
+    });
+    on("tap", async (args) => {
+        const r = requireCoords(args, ["x", "y"]);
+        if ("error" in r)
+            return { ok: false, error: `tap ${r.error}` };
+        await controller.tap(r.coords[0], r.coords[1]);
+        return ok();
+    });
+    on("double_tap", async (args) => {
+        const r = requireCoords(args, ["x", "y"]);
+        if ("error" in r)
+            return { ok: false, error: `double_tap ${r.error}` };
+        await controller.doubleTap(r.coords[0], r.coords[1]);
+        return ok();
+    });
+    on("long_press", async (args) => {
+        const r = requireCoords(args, ["x", "y"]);
+        if ("error" in r)
+            return { ok: false, error: `long_press ${r.error}` };
+        await controller.longPress(r.coords[0], r.coords[1], num(args["duration"], 1500));
+        return ok();
+    });
+    on("swipe", async (args) => {
+        const r = requireCoords(args, ["x1", "y1", "x2", "y2"]);
+        if ("error" in r)
+            return { ok: false, error: `swipe ${r.error}` };
+        await controller.swipe(r.coords[0], r.coords[1], r.coords[2], r.coords[3], num(args["duration"], 300));
+        return ok();
+    });
+    on("input", async (args) => asActionResult(await controller.typeText(String(args["text"] ?? ""))));
+    on("key", async (args) => asActionResult(await controller.pressKey(String(args["key"] ?? ""))));
+    on("launch_app", async (args) => asActionResult(await controller.launchApp(String(args["app"] ?? ""))));
+    on("find_element", async (args) => asActionResult(await controller.findElement(String(args["text"] ?? ""))));
+    on("clear_text", async () => asActionResult(await controller.clearText()));
+    on("hide_keyboard", async () => asActionResult(await controller.hideKeyboard()));
+}
+export async function runControlTunnel(options) {
+    const connect = options.connect ?? defaultConnect;
+    const socket = connect(options.wsUrl, options.deviceToken);
+    registerHandlers(socket, options.controller);
+    await new Promise((resolve, reject) => {
+        let shuttingDown = false;
+        const cleanup = () => {
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            socket.close();
+            resolve();
+        };
+        socket.on("connect", () => {
+            console.log(`Connected to Aximo as "${options.deviceName}" (${options.wsUrl}${SOCKET_PATH})`);
+        });
+        socket.on("connect_error", (err) => {
+            // socket.active is false once reconnection is given up; reject so the CLI exits non-zero.
+            if (!socket.active) {
+                socket.close();
+                reject(new Error(`Connection error: ${err.message}`));
+                return;
+            }
+            console.error(`Connection error: ${err.message}`);
+        });
+        socket.on("disconnect", (reason) => {
+            // socket.active is false when the disconnect is terminal (the client won't reconnect).
+            if (!socket.active) {
+                socket.close();
+                reject(new Error(`Disconnected: ${reason}`));
+                return;
+            }
+            console.log(`Disconnected: ${reason}`);
+        });
+        socket.on("server_shutting_down", () => {
+            console.log("Server is shutting down; awaiting reconnect...");
+        });
+        process.on("SIGINT", () => {
+            console.log("\nDisconnecting...");
+            cleanup();
+        });
+        process.on("SIGTERM", () => {
+            cleanup();
+        });
+    });
+}

package/dist/mobile-control/tunnel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mobile-control/tunnel.test.js

@@ -0,0 +1,155 @@
+import { describe, expect, it, vi } from "vitest";
+import { registerHandlers } from "./tunnel.js";
+class FakeSocket {
+    handlers = new Map();
+    on(event, handler) {
+        this.handlers.set(event, handler);
+        return this;
+    }
+    emit(event, args) {
+        const handler = this.handlers.get(event);
+        if (!handler)
+            throw new Error(`no handler for ${event}`);
+        return new Promise((resolve) => handler(args, resolve));
+    }
+}
+function stubController(overrides = {}) {
+    const base = {
+        screenshot: vi.fn(async () => Buffer.from([1, 2, 3])),
+        tap: vi.fn(async () => { }),
+        doubleTap: vi.fn(async () => { }),
+        longPress: vi.fn(async () => { }),
+        swipe: vi.fn(async () => { }),
+        typeText: vi.fn(async () => ({ ok: true })),
+        pressKey: vi.fn(async () => ({ ok: true })),
+        launchApp: vi.fn(async () => ({ ok: true })),
+        findElement: vi.fn(async () => ({ ok: true })),
+        clearText: vi.fn(async () => ({ ok: true })),
+        hideKeyboard: vi.fn(async () => ({ ok: true })),
+        close: vi.fn(async () => { }),
+    };
+    return { ...base, ...overrides };
+}
+function wire(controller) {
+    const socket = new FakeSocket();
+    registerHandlers(socket, controller);
+    return socket;
+}
+describe("registerHandlers", () => {
+    it("ping acks { ok: true }", async () => {
+        const socket = wire(stubController());
+        await expect(socket.emit("ping", {})).resolves.toEqual({ ok: true });
+    });
+    it("screenshot acks the raw Buffer", async () => {
+        const socket = wire(stubController());
+        const result = await socket.emit("screenshot", {});
+        expect(Buffer.isBuffer(result)).toBe(true);
+        expect(result.equals(Buffer.from([1, 2, 3]))).toBe(true);
+    });
+    it("tap forwards coordinates and acks ok", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await expect(socket.emit("tap", { x: 5, y: 9 })).resolves.toEqual({ ok: true });
+        expect(tap).toHaveBeenCalledWith(5, 9);
+    });
+    it("tap rejects missing coordinates without calling the controller", async () => {
+        const tap = vi.fn(async () => { });
+        const socket = wire(stubController({ tap }));
+        await expect(socket.emit("tap", {})).resolves.toEqual({
+            ok: false,
+            error: "tap requires numeric coordinates",
+        });
+        expect(tap).not.toHaveBeenCalled();
+    });
+    it("swipe rejects a non-finite coordinate without calling the controller", async () => {
+        const swipe = vi.fn(async () => { });
+        const socket = wire(stubController({ swipe }));
+        await expect(socket.emit("swipe", { x1: 1, y1: 2, x2: "3", y2: 4 })).resolves.toEqual({
+            ok: false,
+            error: "swipe requires numeric coordinates",
+        });
+        expect(swipe).not.toHaveBeenCalled();
+    });
+    it("long_press forwards duration in ms", async () => {
+        const longPress = vi.fn(async () => { });
+        const socket = wire(stubController({ longPress }));
+        await socket.emit("long_press", { x: 1, y: 2, duration: 1500 });
+        expect(longPress).toHaveBeenCalledWith(1, 2, 1500);
+    });
+    it("swipe forwards all coordinates and duration", async () => {
+        const swipe = vi.fn(async () => { });
+        const socket = wire(stubController({ swipe }));
+        await socket.emit("swipe", { x1: 1, y1: 2, x2: 3, y2: 4, duration: 250 });
+        expect(swipe).toHaveBeenCalledWith(1, 2, 3, 4, 250);
+    });
+    it("input forwards the text", async () => {
+        const typeText = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ typeText }));
+        await expect(socket.emit("input", { text: "hello" })).resolves.toEqual({ ok: true });
+        expect(typeText).toHaveBeenCalledWith("hello");
+    });
+    it("key acks the structured failure for unsupported keys", async () => {
+        const pressKey = vi.fn(async () => ({ ok: false, error: "Unsupported key: f1" }));
+        const socket = wire(stubController({ pressKey }));
+        await expect(socket.emit("key", { key: "f1" })).resolves.toEqual({
+            ok: false,
+            error: "Unsupported key: f1",
+        });
+    });
+    it("find_element forwards the text and acks ok", async () => {
+        const findElement = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ findElement }));
+        await expect(socket.emit("find_element", { text: "Sign in" })).resolves.toEqual({ ok: true });
+        expect(findElement).toHaveBeenCalledWith("Sign in");
+    });
+    it("clear_text acks ok", async () => {
+        const clearText = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ clearText }));
+        await expect(socket.emit("clear_text", {})).resolves.toEqual({ ok: true });
+        expect(clearText).toHaveBeenCalledOnce();
+    });
+    it("clear_text acks the structured failure", async () => {
+        const clearText = vi.fn(async () => ({ ok: false, error: "no focused field" }));
+        const socket = wire(stubController({ clearText }));
+        await expect(socket.emit("clear_text", {})).resolves.toEqual({
+            ok: false,
+            error: "no focused field",
+        });
+    });
+    it("hide_keyboard acks ok", async () => {
+        const hideKeyboard = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ hideKeyboard }));
+        await expect(socket.emit("hide_keyboard", {})).resolves.toEqual({ ok: true });
+        expect(hideKeyboard).toHaveBeenCalledOnce();
+    });
+    it("datetime falls back to a humanized host clock + timezone when the device can't report", async () => {
+        const socket = wire(stubController());
+        const result = (await socket.emit("datetime", {}));
+        expect(typeof result.datetime).toBe("string");
+        expect(result.datetime.length).toBeGreaterThan(0);
+        expect(result.datetime).not.toContain("T"); // humanized, not raw ISO
+        expect(typeof result.timezone).toBe("string");
+        expect(result.timezone.length).toBeGreaterThan(0);
+    });
+    it("datetime prefers the phone's clock when the controller reports it", async () => {
+        const getDeviceTime = vi.fn(async () => ({
+            datetime: "Friday, June 27, 2026, 10:30 AM",
+            timezone: "America/New_York",
+        }));
+        const socket = wire(stubController({ getDeviceTime }));
+        const result = (await socket.emit("datetime", {}));
+        expect(getDeviceTime).toHaveBeenCalledOnce();
+        expect(result.datetime).toBe("Friday, June 27, 2026, 10:30 AM");
+        expect(result.timezone).toBe("America/New_York");
+    });
+    it("converts a thrown controller error into { ok: false, error }", async () => {
+        const tap = vi.fn(async () => {
+            throw new Error("device offline");
+        });
+        const socket = wire(stubController({ tap }));
+        await expect(socket.emit("tap", { x: 1, y: 1 })).resolves.toEqual({
+            ok: false,
+            error: "device offline",
+        });
+    });
+});

package/dist/mobile-control/webdriver.d.ts

@@ -0,0 +1,31 @@
+export interface WebDriverTransport {
+    request(method: "GET" | "POST" | "DELETE", path: string, body?: unknown): Promise<unknown>;
+}
+export declare function fetchTransport(baseUrl: string): WebDriverTransport;
+export interface WindowRect {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+}
+export declare class WebDriverSession {
+    private readonly transport;
+    private sessionId;
+    constructor(transport: WebDriverTransport);
+    get id(): string | null;
+    createSession(capabilities: Record<string, unknown>): Promise<string>;
+    deleteSession(): Promise<void>;
+    private requireId;
+    screenshot(): Promise<Buffer>;
+    windowRect(): Promise<WindowRect>;
+    performActions(actions: unknown[]): Promise<void>;
+    releaseActions(): Promise<void>;
+    getActiveElement(): Promise<string | null>;
+    findElement(using: string, value: string): Promise<string | null>;
+    elementClick(elementRef: string): Promise<void>;
+    elementClear(elementRef: string): Promise<void>;
+    elementSendKeys(elementRef: string, text: string): Promise<void>;
+    execute(script: string, args?: unknown[]): Promise<unknown>;
+    setValueOnActiveElement(text: string): Promise<void>;
+}
+export declare const ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";

package/dist/mobile-control/webdriver.js

@@ -0,0 +1,137 @@
+function extractError(value) {
+    if (value && typeof value === "object") {
+        const err = value;
+        if (typeof err.error === "string" && err.error.length > 0) {
+            return err.message && typeof err.message === "string"
+                ? `${err.error}: ${err.message}`
+                : err.error;
+        }
+    }
+    return null;
+}
+export function fetchTransport(baseUrl) {
+    const root = baseUrl.replace(/\/$/, "");
+    return {
+        async request(method, path, body) {
+            const headers = { Accept: "application/json" };
+            const init = { method, headers };
+            if (body !== undefined) {
+                headers["Content-Type"] = "application/json";
+                init.body = JSON.stringify(body);
+            }
+            const res = await fetch(`${root}${path}`, init);
+            const text = await res.text();
+            let parsed;
+            try {
+                parsed = text.length > 0 ? JSON.parse(text) : {};
+            }
+            catch {
+                parsed = { value: text };
+            }
+            const valueError = extractError(parsed.value);
+            if (!res.ok || valueError) {
+                const detail = valueError ??
+                    extractError(parsed) ??
+                    (text.trim() ? text.slice(0, 500) : `HTTP ${res.status}`);
+                throw new Error(`WebDriver ${method} ${path} failed: ${detail}`);
+            }
+            return parsed.value;
+        },
+    };
+}
+export class WebDriverSession {
+    transport;
+    sessionId = null;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    get id() {
+        return this.sessionId;
+    }
+    async createSession(capabilities) {
+        const value = (await this.transport.request("POST", "/session", {
+            capabilities: { alwaysMatch: capabilities, firstMatch: [{}] },
+        }));
+        const sessionId = value?.sessionId;
+        if (!sessionId || typeof sessionId !== "string") {
+            throw new Error("WebDriver createSession did not return a sessionId");
+        }
+        this.sessionId = sessionId;
+        return sessionId;
+    }
+    async deleteSession() {
+        if (!this.sessionId)
+            return;
+        const id = this.sessionId;
+        this.sessionId = null;
+        await this.transport.request("DELETE", `/session/${id}`);
+    }
+    requireId() {
+        if (!this.sessionId)
+            throw new Error("WebDriver session is not open");
+        return this.sessionId;
+    }
+    async screenshot() {
+        const value = (await this.transport.request("GET", `/session/${this.requireId()}/screenshot`));
+        return Buffer.from(value, "base64");
+    }
+    async windowRect() {
+        const value = (await this.transport.request("GET", `/session/${this.requireId()}/window/rect`));
+        return {
+            width: Number(value?.width ?? 0),
+            height: Number(value?.height ?? 0),
+            x: Number(value?.x ?? 0),
+            y: Number(value?.y ?? 0),
+        };
+    }
+    async performActions(actions) {
+        await this.transport.request("POST", `/session/${this.requireId()}/actions`, { actions });
+    }
+    async releaseActions() {
+        await this.transport.request("DELETE", `/session/${this.requireId()}/actions`);
+    }
+    async getActiveElement() {
+        const value = await this.transport.request("GET", `/session/${this.requireId()}/element/active`);
+        return elementId(value);
+    }
+    async findElement(using, value) {
+        const result = await this.transport.request("POST", `/session/${this.requireId()}/element`, {
+            using,
+            value,
+        });
+        return elementId(result);
+    }
+    async elementClick(elementRef) {
+        await this.transport.request("POST", `/session/${this.requireId()}/element/${elementRef}/click`, {});
+    }
+    async elementClear(elementRef) {
+        await this.transport.request("POST", `/session/${this.requireId()}/element/${elementRef}/clear`, {});
+    }
+    async elementSendKeys(elementRef, text) {
+        await this.transport.request("POST", `/session/${this.requireId()}/element/${elementRef}/value`, { text, value: [...text] });
+    }
+    async execute(script, args = []) {
+        return this.transport.request("POST", `/session/${this.requireId()}/execute/sync`, {
+            script,
+            args,
+        });
+    }
+    async setValueOnActiveElement(text) {
+        const active = await this.getActiveElement();
+        if (!active)
+            throw new Error("No active element to receive text");
+        await this.elementSendKeys(active, text);
+    }
+}
+export const ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";
+function elementId(value) {
+    if (value && typeof value === "object") {
+        const ref = value[ELEMENT_KEY];
+        if (typeof ref === "string")
+            return ref;
+        const legacy = value["ELEMENT"];
+        if (typeof legacy === "string")
+            return legacy;
+    }
+    return null;
+}

package/dist/mobile-control/webdriver.test.d.ts

@@ -0,0 +1 @@
+export {};