@autifyhq/aximo-cli 0.8.0 → 0.9.0

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

@@ -12,6 +12,8 @@ const ANDROID_KEY_CODES = {
 };
 const ANDROID_KEYCODE_A = 29;
 const ANDROID_META_CTRL_ON = 4096;
+// Chars that break Android's `mobile: type` (adb shell input text): shell metachars, non-ASCII.
+const ANDROID_INPUT_TEXT_UNSAFE = /[^A-Za-z0-9 @:,./+_=-]/;
 const IOS_BUTTONS = {
     home: "home",
 };
@@ -155,6 +157,31 @@ export class AppiumController {
             { type: "pointerUp", button: 0 },
         ]);
     }
+    // Two-finger vertical pinch: scale < 1 pinches in (zoom out), > 1 spreads (zoom in).
+    async pinchZoom(x, y, scale, durationMs) {
+        await this.ensureSession();
+        const [cx, cy] = await this.toPoint(x, y);
+        const startOffset = 100;
+        const endOffset = startOffset * scale;
+        const duration = Math.max(0, Math.round(durationMs));
+        const finger = (id, startY, endY) => ({
+            type: "pointer",
+            id,
+            parameters: { pointerType: "touch" },
+            actions: [
+                { type: "pointerMove", duration: 0, x: cx, y: Math.round(startY) },
+                { type: "pointerDown", button: 0 },
+                { type: "pause", duration: 50 },
+                { type: "pointerMove", duration, x: cx, y: Math.round(endY) },
+                { type: "pointerUp", button: 0 },
+            ],
+        });
+        await this.session.performActions([
+            finger("finger1", cy - startOffset / 2, cy - endOffset / 2),
+            finger("finger2", cy + startOffset / 2, cy + endOffset / 2),
+        ]);
+        await this.session.releaseActions();
+    }
     async performPointer(actions) {
         await this.session.performActions(this.pointerAction(actions));
         await this.session.releaseActions();
@@ -163,16 +190,42 @@ export class AppiumController {
         await this.ensureSession();
         try {
             if (this.platform === "android") {
+                if (ANDROID_INPUT_TEXT_UNSAFE.test(text)) {
+                    const active = await this.activeElementOrNull();
+                    if (!active) {
+                        return {
+                            ok: false,
+                            error: "Cannot type special or non-ASCII characters: no input field is focused. Tap the field first.",
+                        };
+                    }
+                    await this.session.elementSendKeys(active, text);
+                    return { ok: true };
+                }
                 await this.session.execute("mobile: type", [{ text }]);
                 return { ok: true };
             }
-            await this.session.setValueOnActiveElement(text);
+            // XCUITest: per-char W3C key actions; no focused element required.
+            const actions = [...text].flatMap((char) => [
+                { type: "keyDown", value: char },
+                { type: "keyUp", value: char },
+            ]);
+            await this.session.performActions([{ type: "key", id: "keyboard", actions }]);
+            await this.session.releaseActions();
             return { ok: true };
         }
         catch (error) {
             return fail(error);
         }
     }
+    // Some drivers report "no focus" by rejecting; treat that as null.
+    async activeElementOrNull() {
+        try {
+            return await this.session.getActiveElement();
+        }
+        catch {
+            return null;
+        }
+    }
     async clearText() {
         await this.ensureSession();
         try {
@@ -277,7 +330,8 @@ export class AppiumController {
         for (const [using, value] of strategies) {
             try {
                 const ref = await this.session.findElement(using, value);
-                if (ref)
+                // Skip hidden matches so the next strategy can find a visible one.
+                if (ref && (await this.session.elementDisplayed(ref)))
                     return ref;
             }
             catch { }
@@ -294,6 +348,40 @@ export class AppiumController {
             return { ok: true };
         }
     }
+    async rotateDevice(orientation) {
+        await this.ensureSession();
+        try {
+            const wantLandscape = orientation === "landscape";
+            await this.session.setOrientation(wantLandscape ? "LANDSCAPE" : "PORTRAIT");
+            // Rotation changes the window rect, so the cached pixel->point scale is stale.
+            this.scaling = null;
+            // Poll up to 2s until the OS reports the new dimensions; rotation speed varies.
+            const deadline = Date.now() + 2000;
+            while (Date.now() < deadline) {
+                try {
+                    const rect = await this.session.windowRect();
+                    if (rect.width > rect.height === wantLandscape)
+                        break;
+                }
+                catch { }
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
+    async setLocation(latitude, longitude, altitude) {
+        await this.ensureSession();
+        try {
+            await this.session.setGeoLocation({ latitude, longitude, altitude });
+            return { ok: true };
+        }
+        catch (error) {
+            return fail(error);
+        }
+    }
     async getDeviceTime() {
         await this.ensureSession();
         try {

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

@@ -11,24 +11,47 @@ function fakeTransport(options = {}) {
     const calls = [];
     const windowWidth = options.windowWidth ?? 400;
     const screenshotWidth = options.screenshotWidth ?? 400;
+    const findQueue = options.findElementRefs ? [...options.findElementRefs] : null;
+    let landscape = false;
     const transport = {
         async request(method, path, body) {
             calls.push({ method, path, body });
             if (method === "POST" && path === "/session") {
                 return { sessionId: "sess-1" };
             }
+            if (path.endsWith("/orientation")) {
+                landscape = body.orientation === "LANDSCAPE";
+                return {};
+            }
+            if (path.endsWith("/location")) {
+                if (options.locationError)
+                    throw new Error(options.locationError);
+                return {};
+            }
             if (path.endsWith("/screenshot")) {
                 return pngWithWidth(screenshotWidth);
             }
             if (path.endsWith("/window/rect")) {
-                return { width: windowWidth, height: windowWidth * 2, x: 0, y: 0 };
+                return landscape
+                    ? { width: windowWidth * 2, height: windowWidth, x: 0, y: 0 }
+                    : { width: windowWidth, height: windowWidth * 2, x: 0, y: 0 };
             }
             if (path.endsWith("/element/active")) {
+                if (options.activeElementError)
+                    throw new Error(options.activeElementError);
                 const ref = options.activeElement === undefined ? "active-el" : options.activeElement;
                 return ref ? { [ELEMENT_KEY]: ref } : null;
             }
+            if (method === "GET" && path.endsWith("/displayed")) {
+                const ref = path.split("/").at(-2) ?? "";
+                return options.displayed ? options.displayed(ref) : true;
+            }
             if (method === "POST" && path.endsWith("/element")) {
-                const ref = options.findElementRef === undefined ? "found-el" : options.findElementRef;
+                const ref = findQueue
+                    ? (findQueue.shift() ?? null)
+                    : options.findElementRef === undefined
+                        ? "found-el"
+                        : options.findElementRef;
                 return ref ? { [ELEMENT_KEY]: ref } : null;
             }
             return {};
@@ -66,6 +89,12 @@ function pointerActions(calls) {
     const groups = body["actions"];
     return groups[0]?.actions ?? [];
 }
+function lastPointerActions(calls) {
+    const actionCalls = calls.filter((c) => c.path.endsWith("/actions") && c.method === "POST");
+    const body = (actionCalls[actionCalls.length - 1]?.body ?? {});
+    const groups = body["actions"];
+    return groups[0]?.actions ?? [];
+}
 describe("AppiumController session capabilities", () => {
     it("sends Android UiAutomator2 caps", async () => {
         const { controller, calls } = makeController("android");
@@ -145,6 +174,75 @@ describe("AppiumController touch actions", () => {
         expect(downs).toHaveLength(2);
     });
 });
+describe("AppiumController pinch zoom", () => {
+    it("sends two synchronized touch pointers split around the scaled center", async () => {
+        const { controller, calls } = makeController("ios", { windowWidth: 400, screenshotWidth: 800 });
+        await controller.pinchZoom(200, 400, 2, 500);
+        const body = bodyOf(calls, (c) => c.path.endsWith("/actions") && c.method === "POST");
+        const groups = body["actions"];
+        expect(groups).toHaveLength(2);
+        expect(groups.every((g) => g.type === "pointer" && g.parameters.pointerType === "touch")).toBe(true);
+        expect(groups[0]?.id).not.toBe(groups[1]?.id);
+        // Center scales 2x to (100, 200); start offset ±50, end offset ±100 (100 * scale / 2).
+        expect(groups[0]?.actions[0]).toMatchObject({ type: "pointerMove", x: 100, y: 150 });
+        expect(groups[0]?.actions[3]).toMatchObject({
+            type: "pointerMove",
+            x: 100,
+            y: 100,
+            duration: 500,
+        });
+        expect(groups[1]?.actions[0]).toMatchObject({ type: "pointerMove", x: 100, y: 250 });
+        expect(groups[1]?.actions[3]).toMatchObject({
+            type: "pointerMove",
+            x: 100,
+            y: 300,
+            duration: 500,
+        });
+        expect(calls.some((c) => c.method === "DELETE" && c.path.endsWith("/actions"))).toBe(true);
+    });
+    it("moves fingers toward the center when scale < 1 (zoom out)", async () => {
+        const { controller, calls } = makeController("android");
+        await controller.pinchZoom(100, 300, 0.5, 600);
+        const body = bodyOf(calls, (c) => c.path.endsWith("/actions") && c.method === "POST");
+        const groups = body["actions"];
+        expect(groups[0]?.actions[3]).toMatchObject({ x: 100, y: 275 });
+        expect(groups[1]?.actions[3]).toMatchObject({ x: 100, y: 325 });
+    });
+});
+describe("AppiumController rotation + location", () => {
+    it("rotateDevice posts the W3C orientation and refreshes coordinate scaling", async () => {
+        const { controller, calls } = makeController("ios", { windowWidth: 400, screenshotWidth: 800 });
+        await controller.tap(200, 100); // caches the 2x pixel->point scale
+        const result = await controller.rotateDevice("landscape");
+        expect(result.ok).toBe(true);
+        const body = bodyOf(calls, (c) => c.path.endsWith("/orientation"));
+        expect(body["orientation"]).toBe("LANDSCAPE");
+        // Landscape rect is 800pt wide -> scale is 1 now; a stale cache would halve these.
+        await controller.tap(200, 100);
+        const move = lastPointerActions(calls)[0];
+        expect(move.x).toBe(200);
+        expect(move.y).toBe(100);
+    });
+    it("rotateDevice maps portrait to PORTRAIT", async () => {
+        const { controller, calls } = makeController("android");
+        const result = await controller.rotateDevice("portrait");
+        expect(result.ok).toBe(true);
+        expect(bodyOf(calls, (c) => c.path.endsWith("/orientation"))["orientation"]).toBe("PORTRAIT");
+    });
+    it("setLocation posts the W3C location body", async () => {
+        const { controller, calls } = makeController("android");
+        const result = await controller.setLocation(35.68, 139.69, 10);
+        expect(result.ok).toBe(true);
+        const body = bodyOf(calls, (c) => c.path.endsWith("/location"));
+        expect(body["location"]).toEqual({ latitude: 35.68, longitude: 139.69, altitude: 10 });
+    });
+    it("setLocation returns the WebDriver failure as a structured error", async () => {
+        const { controller } = makeController("android", { locationError: "mock location denied" });
+        const result = await controller.setLocation(1, 2, 0);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain("mock location denied");
+    });
+});
 describe("AppiumController text + keys", () => {
     it("typeText on Android uses mobile: type", async () => {
         const { controller, calls } = makeController("android");
@@ -154,12 +252,41 @@ describe("AppiumController text + keys", () => {
         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("typeText on Android types unsafe text into the focused element", async () => {
+        const { controller, calls } = makeController("android", { activeElement: "el-1" });
+        const result = await controller.typeText("パスワード$1!");
+        expect(result.ok).toBe(true);
+        expect(calls.some((c) => c.path.endsWith("/execute/sync"))).toBe(false);
+        const send = bodyOf(calls, (c) => c.path.endsWith("/element/el-1/value"));
+        expect(send["text"]).toBe("パスワード$1!");
+    });
+    it("typeText on Android returns a clear error for unsafe text with no focused element", async () => {
+        const { controller } = makeController("android", { activeElement: null });
+        const result = await controller.typeText("p@ss!word");
+        expect(result.ok).toBe(false);
+        expect(result.error).toBe("Cannot type special or non-ASCII characters: no input field is focused. Tap the field first.");
+    });
+    it("typeText on Android treats an active-element rejection as no focus", async () => {
+        const { controller } = makeController("android", { activeElementError: "no such element" });
+        const result = await controller.typeText("héllo");
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain("no input field is focused");
+    });
+    it("typeText on iOS sends per-char key actions without resolving the active element", async () => {
+        const { controller, calls } = makeController("ios", { activeElement: null });
+        const result = await controller.typeText("hi");
+        expect(result.ok).toBe(true);
+        expect(calls.some((c) => c.path.endsWith("/element/active"))).toBe(false);
+        const body = bodyOf(calls, (c) => c.path.endsWith("/actions") && c.method === "POST");
+        const groups = body["actions"];
+        expect(groups[0]?.type).toBe("key");
+        expect(groups[0]?.actions).toEqual([
+            { type: "keyDown", value: "h" },
+            { type: "keyUp", value: "h" },
+            { type: "keyDown", value: "i" },
+            { type: "keyUp", value: "i" },
+        ]);
+        expect(calls.some((c) => c.method === "DELETE" && c.path.endsWith("/actions"))).toBe(true);
     });
     it("clearText clears the active element when present", async () => {
         const { controller, calls } = makeController("android", { activeElement: "el-9" });
@@ -220,6 +347,27 @@ describe("AppiumController findElement", () => {
         expect(result.ok).toBe(false);
         expect(result.error).toContain("not found");
     });
+    it("skips a non-displayed match and clicks the next strategy's visible one", async () => {
+        const { controller, calls } = makeController("android", {
+            findElementRefs: ["hidden-el", "vis-el"],
+            displayed: (ref) => ref === "vis-el",
+        });
+        const result = await controller.findElement("Sign in");
+        expect(result.ok).toBe(true);
+        expect(calls.some((c) => c.path.endsWith("/element/hidden-el/click"))).toBe(false);
+        expect(calls.some((c) => c.path.endsWith("/element/vis-el/click"))).toBe(true);
+        expect(calls.filter((c) => c.method === "POST" && c.path.endsWith("/element"))).toHaveLength(2);
+    });
+    it("treats a match that is never displayed as not found", async () => {
+        const { controller, calls } = makeController("ios", {
+            findElementRef: "hidden-el",
+            displayed: () => false,
+        });
+        const result = await controller.findElement("OK");
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain("not found");
+        expect(calls.some((c) => c.path.includes("/click"))).toBe(false);
+    });
 });
 describe("AppiumController launch + lifecycle", () => {
     it("launchApp uses mobile: activateApp with appId on Android", async () => {

package/dist/mobile-control/bundle-id-map.js

@@ -12,12 +12,15 @@ export function withBundleIdTranslation(controller, map) {
         doubleTap: (x, y) => controller.doubleTap(x, y),
         longPress: (x, y, durationMs) => controller.longPress(x, y, durationMs),
         swipe: (x1, y1, x2, y2, durationMs) => controller.swipe(x1, y1, x2, y2, durationMs),
+        pinchZoom: (x, y, scale, durationMs) => controller.pinchZoom(x, y, scale, durationMs),
         typeText: (text) => controller.typeText(text),
         pressKey: (key) => controller.pressKey(key),
         launchApp: (app) => controller.launchApp(map.get(app) ?? app),
         findElement: (text) => controller.findElement(text),
         clearText: () => controller.clearText(),
         hideKeyboard: () => controller.hideKeyboard(),
+        rotateDevice: (orientation) => controller.rotateDevice(orientation),
+        setLocation: (latitude, longitude, altitude) => controller.setLocation(latitude, longitude, altitude),
         close: () => controller.close(),
     };
     if (controller.getDeviceTime) {

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

@@ -8,12 +8,15 @@ export interface MobileController {
     doubleTap(x: number, y: number): Promise<void>;
     longPress(x: number, y: number, durationMs: number): Promise<void>;
     swipe(x1: number, y1: number, x2: number, y2: number, durationMs: number): Promise<void>;
+    pinchZoom(x: number, y: number, scale: number, durationMs: number): Promise<void>;
     typeText(text: string): Promise<ActionResult>;
     pressKey(key: string): Promise<ActionResult>;
     launchApp(app: string): Promise<ActionResult>;
     findElement(text: string): Promise<ActionResult>;
     clearText(): Promise<ActionResult>;
     hideKeyboard(): Promise<ActionResult>;
+    rotateDevice(orientation: "portrait" | "landscape"): Promise<ActionResult>;
+    setLocation(latitude: number, longitude: number, altitude: number): Promise<ActionResult>;
     getDeviceTime?(): Promise<{
         datetime: string;
         timezone: string;

package/dist/mobile-control/tunnel.js

@@ -130,6 +130,29 @@ export function registerHandlers(socket, controller, installApp) {
         await controller.swipe(r.coords[0], r.coords[1], r.coords[2], r.coords[3], num(args["duration"], 300));
         return ok();
     });
+    on("pinch_zoom", async (args) => {
+        const r = requireCoords(args, ["x", "y"]);
+        if ("error" in r)
+            return { ok: false, error: `pinch_zoom ${r.error}` };
+        const scale = reqNum(args, "scale");
+        if (scale === null)
+            return { ok: false, error: "pinch_zoom requires a numeric scale" };
+        await controller.pinchZoom(r.coords[0], r.coords[1], scale, num(args["duration"], 600));
+        return ok();
+    });
+    on("rotate_device", async (args) => {
+        const orientation = String(args["orientation"] ?? "").toLowerCase();
+        if (orientation !== "portrait" && orientation !== "landscape") {
+            return { ok: false, error: 'rotate_device requires orientation "portrait" or "landscape"' };
+        }
+        return asActionResult(await controller.rotateDevice(orientation));
+    });
+    on("set_location", async (args) => {
+        const r = requireCoords(args, ["latitude", "longitude"]);
+        if ("error" in r)
+            return { ok: false, error: `set_location ${r.error}` };
+        return asActionResult(await controller.setLocation(r.coords[0], r.coords[1], num(args["altitude"], 0)));
+    });
     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"] ?? ""))));

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

@@ -20,12 +20,15 @@ function stubController(overrides = {}) {
         doubleTap: vi.fn(async () => { }),
         longPress: vi.fn(async () => { }),
         swipe: vi.fn(async () => { }),
+        pinchZoom: 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 })),
+        rotateDevice: vi.fn(async () => ({ ok: true })),
+        setLocation: vi.fn(async () => ({ ok: true })),
         close: vi.fn(async () => { }),
     };
     return { ...base, ...overrides };
@@ -116,6 +119,78 @@ describe("registerHandlers", () => {
             error: "no focused field",
         });
     });
+    it("pinch_zoom forwards center, scale, and duration", async () => {
+        const pinchZoom = vi.fn(async () => { });
+        const socket = wire(stubController({ pinchZoom }));
+        await expect(socket.emit("pinch_zoom", { x: 100, y: 200, scale: 2, duration: 800 })).resolves.toEqual({
+            ok: true,
+        });
+        expect(pinchZoom).toHaveBeenCalledWith(100, 200, 2, 800);
+    });
+    it("pinch_zoom defaults duration to 600ms", async () => {
+        const pinchZoom = vi.fn(async () => { });
+        const socket = wire(stubController({ pinchZoom }));
+        await socket.emit("pinch_zoom", { x: 1, y: 2, scale: 0.5 });
+        expect(pinchZoom).toHaveBeenCalledWith(1, 2, 0.5, 600);
+    });
+    it("pinch_zoom rejects a missing scale without calling the controller", async () => {
+        const pinchZoom = vi.fn(async () => { });
+        const socket = wire(stubController({ pinchZoom }));
+        await expect(socket.emit("pinch_zoom", { x: 1, y: 2 })).resolves.toEqual({
+            ok: false,
+            error: "pinch_zoom requires a numeric scale",
+        });
+        expect(pinchZoom).not.toHaveBeenCalled();
+    });
+    it("pinch_zoom rejects missing coordinates", async () => {
+        const pinchZoom = vi.fn(async () => { });
+        const socket = wire(stubController({ pinchZoom }));
+        await expect(socket.emit("pinch_zoom", { scale: 2 })).resolves.toEqual({
+            ok: false,
+            error: "pinch_zoom requires numeric coordinates",
+        });
+        expect(pinchZoom).not.toHaveBeenCalled();
+    });
+    it("rotate_device forwards a valid orientation", async () => {
+        const rotateDevice = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ rotateDevice }));
+        await expect(socket.emit("rotate_device", { orientation: "landscape" })).resolves.toEqual({
+            ok: true,
+        });
+        expect(rotateDevice).toHaveBeenCalledWith("landscape");
+    });
+    it("rotate_device rejects an invalid orientation without calling the controller", async () => {
+        const rotateDevice = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ rotateDevice }));
+        await expect(socket.emit("rotate_device", { orientation: "sideways" })).resolves.toEqual({
+            ok: false,
+            error: 'rotate_device requires orientation "portrait" or "landscape"',
+        });
+        expect(rotateDevice).not.toHaveBeenCalled();
+    });
+    it("set_location forwards coordinates with altitude defaulting to 0", async () => {
+        const setLocation = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ setLocation }));
+        await expect(socket.emit("set_location", { latitude: 35.68, longitude: 139.69 })).resolves.toEqual({
+            ok: true,
+        });
+        expect(setLocation).toHaveBeenCalledWith(35.68, 139.69, 0);
+    });
+    it("set_location rejects a non-numeric latitude without calling the controller", async () => {
+        const setLocation = vi.fn(async () => ({ ok: true }));
+        const socket = wire(stubController({ setLocation }));
+        await expect(socket.emit("set_location", { latitude: "35", longitude: 139.69 })).resolves.toEqual({
+            ok: false,
+            error: "set_location requires numeric coordinates",
+        });
+        expect(setLocation).not.toHaveBeenCalled();
+    });
+    it("set_location acks the structured failure from the controller", async () => {
+        const setLocation = vi.fn(async () => ({ ok: false, error: "mock location not allowed" }));
+        const socket = wire(stubController({ setLocation }));
+        await expect(socket.emit("set_location", { latitude: 1, longitude: 2, altitude: 30 })).resolves.toEqual({ ok: false, error: "mock location not allowed" });
+        expect(setLocation).toHaveBeenCalledWith(1, 2, 30);
+    });
     it("hide_keyboard acks ok", async () => {
         const hideKeyboard = vi.fn(async () => ({ ok: true }));
         const socket = wire(stubController({ hideKeyboard }));

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

@@ -18,6 +18,12 @@ export declare class WebDriverSession {
     private requireId;
     screenshot(): Promise<Buffer>;
     windowRect(): Promise<WindowRect>;
+    setOrientation(orientation: "PORTRAIT" | "LANDSCAPE"): Promise<void>;
+    setGeoLocation(location: {
+        latitude: number;
+        longitude: number;
+        altitude: number;
+    }): Promise<void>;
     performActions(actions: unknown[]): Promise<void>;
     releaseActions(): Promise<void>;
     getActiveElement(): Promise<string | null>;
@@ -25,7 +31,7 @@ export declare class WebDriverSession {
     elementClick(elementRef: string): Promise<void>;
     elementClear(elementRef: string): Promise<void>;
     elementSendKeys(elementRef: string, text: string): Promise<void>;
+    elementDisplayed(elementRef: string): Promise<boolean>;
     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

@@ -84,6 +84,14 @@ export class WebDriverSession {
             y: Number(value?.y ?? 0),
         };
     }
+    async setOrientation(orientation) {
+        await this.transport.request("POST", `/session/${this.requireId()}/orientation`, {
+            orientation,
+        });
+    }
+    async setGeoLocation(location) {
+        await this.transport.request("POST", `/session/${this.requireId()}/location`, { location });
+    }
     async performActions(actions) {
         await this.transport.request("POST", `/session/${this.requireId()}/actions`, { actions });
     }
@@ -110,18 +118,16 @@ export class WebDriverSession {
     async elementSendKeys(elementRef, text) {
         await this.transport.request("POST", `/session/${this.requireId()}/element/${elementRef}/value`, { text, value: [...text] });
     }
+    async elementDisplayed(elementRef) {
+        const value = await this.transport.request("GET", `/session/${this.requireId()}/element/${elementRef}/displayed`);
+        return value === true;
+    }
     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) {

package/dist/mutate.d.ts

@@ -5,7 +5,7 @@ export interface DryRunResult {
     url: string;
     body?: unknown;
 }
-export declare function dryRunEnvelope(method: string, path: string, body?: unknown): SuccessEnvelope<DryRunResult>;
+export declare function dryRunEnvelope(method: string, pathOrUrl: string, body?: unknown): SuccessEnvelope<DryRunResult>;
 export declare function resolveJsonOverride(jsonFlag: unknown): {
     body: Record<string, unknown>;
 } | {

package/dist/mutate.js

@@ -1,8 +1,10 @@
 import { formatError, formatSuccess, validationError } from "./output.js";
 import { parseJsonBody, JsonBodyError, OPENAPI_URL } from "./validate.js";
 import { getBaseUrl } from "./client.js";
-export function dryRunEnvelope(method, path, body) {
-    const url = `${getBaseUrl()}${path.startsWith("/") ? path : `/${path}`}`;
+export function dryRunEnvelope(method, pathOrUrl, body) {
+    const url = /^https?:\/\//.test(pathOrUrl)
+        ? pathOrUrl
+        : `${getBaseUrl()}${pathOrUrl.startsWith("/") ? pathOrUrl : `/${pathOrUrl}`}`;
     const data = { dryRun: true, method, url };
     if (body !== undefined)
         data.body = body;