@autifyhq/aximo-cli 0.4.0 → 0.6.0

package/dist/mobile-control/appium-controller.js

@@ -0,0 +1,372 @@
+import { iosSigningCapabilities } from "./ios-signing.js";
+import { fetchTransport, WebDriverSession } from "./webdriver.js";
+const ANDROID_KEY_CODES = {
+    enter: 66,
+    delete: 67,
+    tab: 61,
+    space: 62,
+    escape: 111,
+    back: 4,
+    home: 3,
+};
+const ANDROID_KEYCODE_A = 29;
+const ANDROID_META_CTRL_ON = 4096;
+const IOS_BUTTONS = {
+    home: "home",
+};
+const W3C_KEYS = {
+    enter: "\uE007",
+    delete: "\uE003",
+    tab: "\uE004",
+    escape: "\uE00C",
+    space: " ",
+};
+export class AppiumController {
+    session;
+    platform;
+    target;
+    iosSigning;
+    sessionReady = null;
+    scaling = null;
+    constructor(opts) {
+        this.platform = opts.platform;
+        this.target = opts.target;
+        this.iosSigning = opts.iosSigning;
+        const transport = opts.transport ?? fetchTransport(opts.endpoint);
+        this.session = new WebDriverSession(transport);
+    }
+    capabilities() {
+        if (this.platform === "android") {
+            return {
+                platformName: "Android",
+                "appium:automationName": "UiAutomator2",
+                "appium:udid": this.target,
+                "appium:noReset": true,
+                "appium:autoLaunch": false,
+                "appium:newCommandTimeout": 0,
+            };
+        }
+        return {
+            platformName: "iOS",
+            "appium:automationName": "XCUITest",
+            "appium:udid": this.target,
+            "appium:newCommandTimeout": 0,
+            // WDA code-signing caps for physical iPhones (empty unless a team id is set).
+            ...(this.iosSigning ? iosSigningCapabilities(this.iosSigning) : {}),
+        };
+    }
+    ensureSession() {
+        if (!this.sessionReady) {
+            this.sessionReady = this.session
+                .createSession(this.capabilities())
+                .then(() => undefined)
+                .catch((err) => {
+                this.sessionReady = null;
+                throw err;
+            });
+        }
+        return this.sessionReady;
+    }
+    // Incoming pixel coords scale to logical points: iOS divides by DPR, Android ~= 1.
+    async scale() {
+        if (this.scaling)
+            return this.scaling.scale;
+        const [rect, shot] = await Promise.all([this.session.windowRect(), this.session.screenshot()]);
+        const pixelWidth = readPngWidth(shot);
+        const scale = rect.width > 0 && pixelWidth > 0 ? pixelWidth / rect.width : 1;
+        this.scaling = { scale: scale > 0 ? scale : 1 };
+        return this.scaling.scale;
+    }
+    async toPoint(x, y) {
+        const s = await this.scale();
+        return [Math.round(x / s), Math.round(y / s)];
+    }
+    pointerAction(actions) {
+        return [
+            {
+                type: "pointer",
+                id: "finger1",
+                parameters: { pointerType: "touch" },
+                actions,
+            },
+        ];
+    }
+    async screenshot() {
+        await this.ensureSession();
+        return this.session.screenshot();
+    }
+    async tap(x, y) {
+        await this.ensureSession();
+        const [px, py] = await this.toPoint(x, y);
+        await this.performPointer([
+            { type: "pointerMove", duration: 0, x: px, y: py },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: 50 },
+            { type: "pointerUp", button: 0 },
+        ]);
+    }
+    async doubleTap(x, y) {
+        await this.ensureSession();
+        const [px, py] = await this.toPoint(x, y);
+        await this.performPointer([
+            { type: "pointerMove", duration: 0, x: px, y: py },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: 50 },
+            { type: "pointerUp", button: 0 },
+            { type: "pause", duration: 50 },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: 50 },
+            { type: "pointerUp", button: 0 },
+        ]);
+    }
+    async longPress(x, y, durationMs) {
+        await this.ensureSession();
+        const [px, py] = await this.toPoint(x, y);
+        await this.performPointer([
+            { type: "pointerMove", duration: 0, x: px, y: py },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: Math.max(0, Math.round(durationMs)) },
+            { type: "pointerUp", button: 0 },
+        ]);
+    }
+    async swipe(x1, y1, x2, y2, durationMs) {
+        await this.ensureSession();
+        const [px1, py1] = await this.toPoint(x1, y1);
+        const [px2, py2] = await this.toPoint(x2, y2);
+        await this.performPointer([
+            { type: "pointerMove", duration: 0, x: px1, y: py1 },
+            { type: "pointerDown", button: 0 },
+            { type: "pointerMove", duration: Math.max(0, Math.round(durationMs)), x: px2, y: py2 },
+            { type: "pointerUp", button: 0 },
+        ]);
+    }
+    async performPointer(actions) {
+        await this.session.performActions(this.pointerAction(actions));
+        await this.session.releaseActions();
+    }
+    async typeText(text) {
+        await this.ensureSession();
+        try {
+            if (this.platform === "android") {
+                await this.session.execute("mobile: type", [{ text }]);
+                return { ok: true };
+            }
+            await this.session.setValueOnActiveElement(text);
+            return { ok: true };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
+    async clearText() {
+        await this.ensureSession();
+        try {
+            const active = await this.session.getActiveElement();
+            if (active) {
+                await this.session.elementClear(active);
+                return { ok: true };
+            }
+        }
+        catch { }
+        if (this.platform === "android") {
+            try {
+                await this.session.execute("mobile: pressKey", [
+                    { keycode: ANDROID_KEYCODE_A, metastate: ANDROID_META_CTRL_ON },
+                ]);
+                await this.session.execute("mobile: pressKey", [{ keycode: ANDROID_KEY_CODES["delete"] }]);
+                return { ok: true };
+            }
+            catch (error) {
+                return fail(error);
+            }
+        }
+        return {
+            ok: false,
+            error: "Could not clear the field: no focused input element was found. " +
+                "Tap the field to focus it before calling clear_text.",
+        };
+    }
+    async pressKey(key) {
+        await this.ensureSession();
+        const normalized = key.toLowerCase().trim();
+        try {
+            if (this.platform === "android") {
+                const code = ANDROID_KEY_CODES[normalized];
+                if (code === undefined)
+                    return { ok: false, error: `Unsupported key: ${key}` };
+                await this.session.execute("mobile: pressKey", [{ keycode: code }]);
+                return { ok: true };
+            }
+            if (normalized === "back") {
+                return {
+                    ok: false,
+                    error: '"back" key is Android-only. On iOS, tap the back button in the UI instead.',
+                };
+            }
+            const button = IOS_BUTTONS[normalized];
+            if (button) {
+                await this.session.execute("mobile: pressButton", [{ name: button }]);
+                return { ok: true };
+            }
+            const w3c = W3C_KEYS[normalized];
+            if (w3c) {
+                await this.session.performActions([
+                    {
+                        type: "key",
+                        id: "keyboard",
+                        actions: [
+                            { type: "keyDown", value: w3c },
+                            { type: "keyUp", value: w3c },
+                        ],
+                    },
+                ]);
+                await this.session.releaseActions();
+                return { ok: true };
+            }
+            return { ok: false, error: `Unsupported key: ${key}` };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
+    async launchApp(app) {
+        if (!app)
+            return { ok: false, error: "launch_app requires an app id" };
+        await this.ensureSession();
+        try {
+            const param = this.platform === "android" ? { appId: app } : { bundleId: app };
+            await this.session.execute("mobile: activateApp", [param]);
+            return { ok: true };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
+    async findElement(text) {
+        if (!text)
+            return { ok: false, error: "find_element requires text" };
+        await this.ensureSession();
+        try {
+            const ref = await this.locate(text);
+            if (!ref)
+                return { ok: false, error: `Element with text "${text}" not found` };
+            await this.session.elementClick(ref);
+            return { ok: true };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
+    async locate(text) {
+        const strategies = this.platform === "android" ? androidStrategies(text) : iosStrategies(text);
+        for (const [using, value] of strategies) {
+            try {
+                const ref = await this.session.findElement(using, value);
+                if (ref)
+                    return ref;
+            }
+            catch { }
+        }
+        return null;
+    }
+    async hideKeyboard() {
+        await this.ensureSession();
+        try {
+            await this.session.execute("mobile: hideKeyboard", []);
+            return { ok: true };
+        }
+        catch {
+            return { ok: true };
+        }
+    }
+    async getDeviceTime() {
+        await this.ensureSession();
+        try {
+            const raw = await this.session.execute("mobile: getDeviceTime", []);
+            if (typeof raw !== "string" || raw.trim().length === 0)
+                return null;
+            const parsed = new Date(raw);
+            if (Number.isNaN(parsed.getTime()))
+                return null;
+            return {
+                datetime: humanizeDateTime(parsed),
+                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async close() {
+        try {
+            await this.session.deleteSession();
+        }
+        catch { }
+    }
+}
+// Builds an XPath string literal that is safe even when `s` contains single quotes.
+function xpathLiteral(s) {
+    if (!s.includes("'"))
+        return `'${s}'`;
+    const parts = s.split("'").map((part) => `'${part}'`);
+    return `concat(${parts.join(`, "'", `)})`;
+}
+// Escapes backslashes and double quotes for a Java UiSelector string argument.
+function uiSelectorLiteral(s) {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+// Escapes single quotes for an iOS NSPredicate string literal.
+function iosPredicateLiteral(s) {
+    return s.replace(/'/g, "\\'");
+}
+function androidStrategies(text) {
+    const lower = text.toLowerCase();
+    return [
+        ["accessibility id", text],
+        ["id", text],
+        ["xpath", `//*[@text=${xpathLiteral(text)}]`],
+        [
+            "xpath",
+            `//*[contains(translate(@text, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), ${xpathLiteral(lower)})]`,
+        ],
+        ["xpath", `//*[@content-desc=${xpathLiteral(text)}]`],
+        ["xpath", `//*[contains(@content-desc, ${xpathLiteral(text)})]`],
+        ["-android uiautomator", `new UiSelector().textContains("${uiSelectorLiteral(text)}")`],
+    ];
+}
+function iosStrategies(text) {
+    const v = iosPredicateLiteral(text);
+    return [
+        ["-ios predicate string", `type == 'XCUIElementTypeButton' AND label == '${v}'`],
+        ["-ios predicate string", `type == 'XCUIElementTypeButton' AND name == '${v}'`],
+        ["accessibility id", text],
+        ["name", text],
+        ["-ios predicate string", `label == '${v}'`],
+        ["-ios predicate string", `name == '${v}'`],
+        ["-ios predicate string", `label CONTAINS '${v}'`],
+    ];
+}
+function humanizeDateTime(date) {
+    return date.toLocaleString("en-US", {
+        weekday: "long",
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true,
+    });
+}
+function fail(error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+}
+function readPngWidth(buffer) {
+    if (buffer.length < 24)
+        return 0;
+    try {
+        return buffer.readUInt32BE(16);
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/mobile-control/appium-controller.test.d.ts

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

package/dist/mobile-control/appium-controller.test.js

@@ -0,0 +1,252 @@
+import { describe, expect, it } from "vitest";
+import { AppiumController } from "./appium-controller.js";
+import { ELEMENT_KEY } from "./webdriver.js";
+function pngWithWidth(width) {
+    const buf = Buffer.alloc(24);
+    buf.writeUInt32BE(width, 16);
+    buf.writeUInt32BE(width, 20);
+    return buf.toString("base64");
+}
+function fakeTransport(options = {}) {
+    const calls = [];
+    const windowWidth = options.windowWidth ?? 400;
+    const screenshotWidth = options.screenshotWidth ?? 400;
+    const transport = {
+        async request(method, path, body) {
+            calls.push({ method, path, body });
+            if (method === "POST" && path === "/session") {
+                return { sessionId: "sess-1" };
+            }
+            if (path.endsWith("/screenshot")) {
+                return pngWithWidth(screenshotWidth);
+            }
+            if (path.endsWith("/window/rect")) {
+                return { width: windowWidth, height: windowWidth * 2, x: 0, y: 0 };
+            }
+            if (path.endsWith("/element/active")) {
+                const ref = options.activeElement === undefined ? "active-el" : options.activeElement;
+                return ref ? { [ELEMENT_KEY]: ref } : null;
+            }
+            if (method === "POST" && path.endsWith("/element")) {
+                const ref = options.findElementRef === undefined ? "found-el" : options.findElementRef;
+                return ref ? { [ELEMENT_KEY]: ref } : null;
+            }
+            return {};
+        },
+    };
+    return { transport, calls };
+}
+function makeController(platform, options) {
+    const { transport, calls } = fakeTransport(options);
+    return {
+        controller: new AppiumController({
+            endpoint: "http://x",
+            platform,
+            target: "udid-1",
+            transport,
+        }),
+        calls,
+    };
+}
+function bodyOf(calls, predicate) {
+    const call = calls.find(predicate);
+    if (!call)
+        throw new Error("expected a matching recorded call");
+    return (call.body ?? {});
+}
+function executeBody(calls) {
+    return bodyOf(calls, (c) => c.path.endsWith("/execute/sync"));
+}
+function caps(calls) {
+    const body = bodyOf(calls, (c) => c.path === "/session" && c.method === "POST");
+    return body["capabilities"].alwaysMatch;
+}
+function pointerActions(calls) {
+    const body = bodyOf(calls, (c) => c.path.endsWith("/actions") && c.method === "POST");
+    const groups = body["actions"];
+    return groups[0]?.actions ?? [];
+}
+describe("AppiumController session capabilities", () => {
+    it("sends Android UiAutomator2 caps", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.screenshot();
+        const c = caps(calls);
+        expect(c["platformName"]).toBe("Android");
+        expect(c["appium:automationName"]).toBe("UiAutomator2");
+        expect(c["appium:udid"]).toBe("udid-1");
+        expect(c["appium:noReset"]).toBe(true);
+        expect(c["appium:autoLaunch"]).toBe(false);
+        expect(c["appium:newCommandTimeout"]).toBe(0);
+    });
+    it("sends iOS XCUITest caps", async () => {
+        const { controller, calls } = makeController("ios");
+        await controller.screenshot();
+        const c = caps(calls);
+        expect(c["platformName"]).toBe("iOS");
+        expect(c["appium:automationName"]).toBe("XCUITest");
+        expect(c["appium:newCommandTimeout"]).toBe(0);
+    });
+    it("creates the session lazily and only once", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.screenshot();
+        await controller.screenshot();
+        expect(calls.filter((c) => c.path === "/session" && c.method === "POST")).toHaveLength(1);
+    });
+});
+describe("AppiumController coordinate scaling", () => {
+    it("halves pixel coords when screenshot is 800px and window is 400pt (iOS)", async () => {
+        const { controller, calls } = makeController("ios", { windowWidth: 400, screenshotWidth: 800 });
+        await controller.tap(200, 100);
+        const actions = pointerActions(calls);
+        const move = actions[0];
+        expect(move.type).toBe("pointerMove");
+        expect(move.x).toBe(100);
+        expect(move.y).toBe(50);
+    });
+    it("keeps coords ~1:1 for Android when scale is 1", async () => {
+        const { controller, calls } = makeController("android", {
+            windowWidth: 400,
+            screenshotWidth: 400,
+        });
+        await controller.tap(123, 45);
+        const move = pointerActions(calls)[0];
+        expect(move.x).toBe(123);
+        expect(move.y).toBe(45);
+    });
+});
+describe("AppiumController touch actions", () => {
+    it("tap builds move/down/pause/up", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.tap(10, 20);
+        const actions = pointerActions(calls).map((a) => a.type);
+        expect(actions).toEqual(["pointerMove", "pointerDown", "pause", "pointerUp"]);
+        expect(calls.some((c) => c.method === "DELETE" && c.path.endsWith("/actions"))).toBe(true);
+    });
+    it("long_press holds for the requested duration", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.longPress(10, 20, 1500);
+        const pause = pointerActions(calls).find((a) => a.type === "pause");
+        expect(pause.duration).toBe(1500);
+    });
+    it("swipe moves start->end with the duration on the second move", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.swipe(10, 20, 30, 40, 250);
+        const actions = pointerActions(calls);
+        expect(actions[0].x).toBe(10);
+        const endMove = actions[2];
+        expect(endMove.type).toBe("pointerMove");
+        expect(endMove.x).toBe(30);
+        expect(endMove.duration).toBe(250);
+    });
+    it("double_tap performs two down/up cycles", async () => {
+        const { controller, calls } = makeController("ios");
+        await controller.doubleTap(5, 5);
+        const downs = pointerActions(calls).filter((a) => a.type === "pointerDown");
+        expect(downs).toHaveLength(2);
+    });
+});
+describe("AppiumController text + keys", () => {
+    it("typeText on Android uses mobile: type", async () => {
+        const { controller, calls } = makeController("android");
+        const result = await controller.typeText("hello");
+        expect(result.ok).toBe(true);
+        const exec = executeBody(calls);
+        expect(exec.script).toBe("mobile: type");
+        expect(exec.args[0]?.["text"]).toBe("hello");
+    });
+    it("typeText on iOS sends keys to the active element", async () => {
+        const { controller, calls } = makeController("ios");
+        await controller.typeText("hi");
+        expect(calls.some((c) => c.path.endsWith("/element/active"))).toBe(true);
+        const send = bodyOf(calls, (c) => c.path.endsWith("/element/active-el/value"));
+        expect(send["text"]).toBe("hi");
+    });
+    it("clearText clears the active element when present", async () => {
+        const { controller, calls } = makeController("android", { activeElement: "el-9" });
+        const result = await controller.clearText();
+        expect(result.ok).toBe(true);
+        expect(calls.some((c) => c.path.endsWith("/element/el-9/clear"))).toBe(true);
+    });
+    it("clearText falls back to Ctrl+A + delete on Android when no active element", async () => {
+        const { controller, calls } = makeController("android", { activeElement: null });
+        const result = await controller.clearText();
+        expect(result.ok).toBe(true);
+        const execs = calls.filter((c) => c.path.endsWith("/execute/sync"));
+        expect(execs).toHaveLength(2);
+        const first = executeBody(calls);
+        expect(first.args[0]?.["keycode"]).toBe(29);
+    });
+    it("clearText returns a structured error on iOS with no active element", async () => {
+        const { controller } = makeController("ios", { activeElement: null });
+        const result = await controller.clearText();
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain("focus");
+    });
+    it("pressKey maps Android keys to mobile: pressKey keycodes", async () => {
+        const { controller, calls } = makeController("android");
+        expect((await controller.pressKey("back")).ok).toBe(true);
+        expect(executeBody(calls).args[0]?.["keycode"]).toBe(4);
+    });
+    it("pressKey rejects 'back' on iOS", async () => {
+        const { controller } = makeController("ios");
+        const result = await controller.pressKey("back");
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain("Android-only");
+    });
+    it("pressKey returns an error for unsupported keys", async () => {
+        const { controller } = makeController("android");
+        const result = await controller.pressKey("f13");
+        expect(result.ok).toBe(false);
+    });
+});
+describe("AppiumController findElement", () => {
+    it("clicks the located element and tries accessibility id first on Android", async () => {
+        const { controller, calls } = makeController("android", { findElementRef: "btn-1" });
+        const result = await controller.findElement("Sign in");
+        expect(result.ok).toBe(true);
+        const firstFind = bodyOf(calls, (c) => c.method === "POST" && c.path.endsWith("/element"));
+        expect(firstFind["using"]).toBe("accessibility id");
+        expect(calls.some((c) => c.path.endsWith("/element/btn-1/click"))).toBe(true);
+    });
+    it("tries the iOS button predicate first", async () => {
+        const { controller, calls } = makeController("ios", { findElementRef: "btn-1" });
+        await controller.findElement("OK");
+        const firstFind = bodyOf(calls, (c) => c.method === "POST" && c.path.endsWith("/element"));
+        expect(firstFind["using"]).toBe("-ios predicate string");
+    });
+    it("returns not-found when no strategy locates the element", async () => {
+        const { controller } = makeController("android", { findElementRef: null });
+        const result = await controller.findElement("Nope");
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain("not found");
+    });
+});
+describe("AppiumController launch + lifecycle", () => {
+    it("launchApp uses mobile: activateApp with appId on Android", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.launchApp("com.example.app");
+        const exec = executeBody(calls);
+        expect(exec.script).toBe("mobile: activateApp");
+        expect(exec.args[0]?.["appId"]).toBe("com.example.app");
+    });
+    it("launchApp uses bundleId on iOS", async () => {
+        const { controller, calls } = makeController("ios");
+        await controller.launchApp("com.example.app");
+        expect(executeBody(calls).args[0]?.["bundleId"]).toBe("com.example.app");
+    });
+    it("hideKeyboard swallows errors and acks ok", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.screenshot();
+        const result = await controller.hideKeyboard();
+        expect(result.ok).toBe(true);
+        const exec = calls.find((c) => c.path.endsWith("/execute/sync") &&
+            c.body.script === "mobile: hideKeyboard");
+        expect(exec).toBeDefined();
+    });
+    it("close deletes the session", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.screenshot();
+        await controller.close();
+        expect(calls.some((c) => c.method === "DELETE" && c.path === "/session/sess-1")).toBe(true);
+    });
+});

package/dist/mobile-control/appium-import.d.ts

@@ -0,0 +1,7 @@
+interface AppiumModule {
+    main: (args: Record<string, unknown>) => Promise<{
+        close(): Promise<void>;
+    }>;
+}
+export declare function importAppium(): Promise<AppiumModule>;
+export {};

package/dist/mobile-control/appium-import.js

@@ -0,0 +1,6 @@
+const APPIUM = "appium";
+export async function importAppium() {
+    // Appium 3 is CJS, so its `main` is under `.default` when imported from ESM.
+    const mod = (await import(APPIUM));
+    return mod.default ?? mod;
+}

package/dist/mobile-control/appium-import.test.d.ts

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

package/dist/mobile-control/appium-import.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+import { importAppium } from "./appium-import.js";
+// Guards the CJS-default unwrap with a real import (Appium 3 exposes `main` under `.default`).
+describe("importAppium", () => {
+    it("resolves the appium module with a callable main()", async () => {
+        const mod = await importAppium();
+        expect(typeof mod.main).toBe("function");
+    });
+});

package/dist/mobile-control/appium-server.d.ts

@@ -0,0 +1,30 @@
+export interface AppiumServerHandle {
+    endpoint: string;
+    stop: () => Promise<void>;
+}
+interface RunningServer {
+    close(): Promise<void>;
+}
+export type AppiumLauncher = (args: Record<string, unknown>) => Promise<RunningServer>;
+export interface StartAppiumServerOptions {
+    launch?: AppiumLauncher;
+    appiumHome?: string;
+    useDrivers?: string[];
+    readyTimeoutMs?: number;
+}
+export declare function getAppiumHome(): string;
+export interface ResolveAndroidSdkDeps {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    platform?: NodeJS.Platform;
+    exists?: (path: string) => boolean;
+}
+/**
+ * Resolve the Android SDK location. Honours ANDROID_HOME / ANDROID_SDK_ROOT when
+ * set and valid, else probes the standard per-OS install location. Appium's
+ * UiAutomator2 driver requires this even when `adb` is already on PATH.
+ */
+export declare function resolveAndroidSdk(deps?: ResolveAndroidSdkDeps): string | null;
+export declare function pickFreePort(): Promise<number>;
+export declare function startAppiumServer(options?: StartAppiumServerOptions): Promise<AppiumServerHandle>;
+export {};