@panicgit/android-test-pilot 0.1.0

package/lib/tiers/uiautomator-tier.d.ts

@@ -0,0 +1,16 @@
+/**
+ * UiAutomatorTier (Tier 2) — UI hierarchy-based detection
+ *
+ * Dumps the current View hierarchy via uiautomator and searches
+ * for elements by resource-id or text. Can also perform tap actions.
+ *
+ * Used when Tier 1 (text-based) cannot determine the result.
+ */
+import { AbstractTier } from "./abstract-tier";
+import { TierContext, TierResult } from "./types";
+export declare class UiAutomatorTier extends AbstractTier {
+    readonly name = "uiautomator";
+    readonly priority = 2;
+    canHandle(context: TierContext): Promise<boolean>;
+    execute(context: TierContext): Promise<TierResult>;
+}

package/lib/tiers/uiautomator-tier.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * UiAutomatorTier (Tier 2) — UI hierarchy-based detection
+ *
+ * Dumps the current View hierarchy via uiautomator and searches
+ * for elements by resource-id or text. Can also perform tap actions.
+ *
+ * Used when Tier 1 (text-based) cannot determine the result.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UiAutomatorTier = void 0;
+const abstract_tier_1 = require("./abstract-tier");
+class UiAutomatorTier extends abstract_tier_1.AbstractTier {
+    name = "uiautomator";
+    priority = 2;
+    async canHandle(context) {
+        try {
+            const robot = this.getAndroidRobot(context);
+            // Verify uiautomator is responsive
+            void robot.adb("shell", "echo", "ping");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async execute(context) {
+        const robot = this.getAndroidRobot(context);
+        // 1. Dump UI hierarchy
+        const elements = await robot.getElementsOnScreen();
+        if (elements.length === 0) {
+            return {
+                tier: this.name,
+                status: "FALLBACK",
+                fallbackHint: "UI hierarchy dump returned zero elements",
+            };
+        }
+        // 2. If there's a tap target, find and tap it
+        const tapTarget = context.step.tapTarget;
+        if (tapTarget) {
+            if (tapTarget.resourceId) {
+                const target = elements.find(el => el.identifier === tapTarget.resourceId);
+                if (target) {
+                    const centerX = target.rect.x + Math.floor(target.rect.width / 2);
+                    const centerY = target.rect.y + Math.floor(target.rect.height / 2);
+                    await robot.tap(centerX, centerY);
+                    return {
+                        tier: this.name,
+                        status: "SUCCESS",
+                        observation: `Tapped ${tapTarget.resourceId} at (${centerX}, ${centerY})`,
+                        rawData: JSON.stringify({ target, elementsCount: elements.length }),
+                    };
+                }
+                // resource-id not found
+                return {
+                    tier: this.name,
+                    status: "FAIL",
+                    observation: `Element with resource-id "${tapTarget.resourceId}" not found in ${elements.length} elements`,
+                    verification: {
+                        passed: false,
+                        expected: `resource-id: ${tapTarget.resourceId}`,
+                        actual: `Not found. Available IDs: ${elements.filter(e => e.identifier).map(e => e.identifier).slice(0, 10).join(", ")}`,
+                    },
+                    rawData: JSON.stringify({ elementsCount: elements.length }),
+                };
+            }
+            if (tapTarget.coordinates) {
+                await robot.tap(tapTarget.coordinates.x, tapTarget.coordinates.y);
+                return {
+                    tier: this.name,
+                    status: "SUCCESS",
+                    observation: `Tapped coordinates (${tapTarget.coordinates.x}, ${tapTarget.coordinates.y})`,
+                };
+            }
+        }
+        // 3. No tap target — return UI hierarchy as observation
+        const summary = elements.slice(0, 20).map(el => ({
+            type: el.type,
+            text: el.text,
+            id: el.identifier,
+        }));
+        return {
+            tier: this.name,
+            status: "SUCCESS",
+            observation: `UI hierarchy: ${elements.length} elements found`,
+            rawData: JSON.stringify(summary),
+        };
+    }
+}
+exports.UiAutomatorTier = UiAutomatorTier;
+//# sourceMappingURL=uiautomator-tier.js.map

package/lib/tiers/uiautomator-tier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uiautomator-tier.js","sourceRoot":"","sources":["../../src/tiers/uiautomator-tier.ts"],"names":[],"mappings":"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"}

package/lib/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function validatePackageName(packageName: string): void;
+export declare function validateLocale(locale: string): void;
+export declare function validateFileExtension(filePath: string, allowedExtensions: string[], toolName: string): void;
+export declare function validateOutputPath(filePath: string): void;

package/lib/utils.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePackageName = validatePackageName;
+exports.validateLocale = validateLocale;
+exports.validateFileExtension = validateFileExtension;
+exports.validateOutputPath = validateOutputPath;
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const robot_1 = require("./robot");
+function validatePackageName(packageName) {
+    if (!/^[a-zA-Z0-9._]+$/.test(packageName)) {
+        throw new robot_1.ActionableError(`Invalid package name: "${packageName}"`);
+    }
+}
+function validateLocale(locale) {
+    if (!/^[a-zA-Z0-9,\- ]+$/.test(locale)) {
+        throw new robot_1.ActionableError(`Invalid locale: "${locale}"`);
+    }
+}
+function getAllowedRoots() {
+    const roots = [
+        node_os_1.default.tmpdir(),
+        process.cwd(),
+    ];
+    // macOS /tmp is a symlink to /private/tmp, add both to be safe
+    if (process.platform === "darwin") {
+        roots.push("/tmp");
+        roots.push("/private/tmp");
+    }
+    return roots.map(r => node_path_1.default.resolve(r));
+}
+function isPathUnderRoot(filePath, root) {
+    const relative = node_path_1.default.relative(root, filePath);
+    if (relative === "") {
+        return false;
+    }
+    if (node_path_1.default.isAbsolute(relative)) {
+        return false;
+    }
+    if (relative.startsWith("..")) {
+        return false;
+    }
+    return true;
+}
+function validateFileExtension(filePath, allowedExtensions, toolName) {
+    const ext = node_path_1.default.extname(filePath).toLowerCase();
+    if (!allowedExtensions.includes(ext)) {
+        throw new robot_1.ActionableError(`${toolName} requires a ${allowedExtensions.join(", ")} file extension, got: "${ext || "(none)"}"`);
+    }
+}
+function resolveWithSymlinks(filePath) {
+    const resolved = node_path_1.default.resolve(filePath);
+    const dir = node_path_1.default.dirname(resolved);
+    const filename = node_path_1.default.basename(resolved);
+    try {
+        return node_path_1.default.join(node_fs_1.default.realpathSync(dir), filename);
+    }
+    catch {
+        return resolved;
+    }
+}
+function validateOutputPath(filePath) {
+    const resolved = resolveWithSymlinks(filePath);
+    const allowedRoots = getAllowedRoots();
+    const isWindows = process.platform === "win32";
+    const isAllowed = allowedRoots.some(root => {
+        if (isWindows) {
+            return isPathUnderRoot(resolved.toLowerCase(), root.toLowerCase());
+        }
+        return isPathUnderRoot(resolved, root);
+    });
+    if (!isAllowed) {
+        const dir = node_path_1.default.dirname(resolved);
+        throw new robot_1.ActionableError(`"${dir}" is not in the list of allowed directories. Allowed directories include the current directory and the temp directory on this host.`);
+    }
+}
+//# sourceMappingURL=utils.js.map

package/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/lib/webdriver-agent.d.ts

@@ -0,0 +1,45 @@
+import { SwipeDirection, ScreenSize, ScreenElement, Orientation } from "./robot";
+export interface SourceTreeElementRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SourceTreeElement {
+    type: string;
+    label?: string;
+    name?: string;
+    value?: string;
+    rawIdentifier?: string;
+    rect: SourceTreeElementRect;
+    isVisible?: string;
+    children?: Array<SourceTreeElement>;
+}
+export interface SourceTree {
+    value: SourceTreeElement;
+}
+export declare class WebDriverAgent {
+    private readonly host;
+    private readonly port;
+    constructor(host: string, port: number);
+    isRunning(): Promise<boolean>;
+    createSession(): Promise<string>;
+    deleteSession(sessionId: string): Promise<any>;
+    withinSession(fn: (url: string) => Promise<any>): Promise<any>;
+    getScreenSize(sessionUrl?: string): Promise<ScreenSize>;
+    sendKeys(keys: string): Promise<void>;
+    pressButton(button: string): Promise<void>;
+    tap(x: number, y: number): Promise<void>;
+    doubleTap(x: number, y: number): Promise<void>;
+    longPress(x: number, y: number, duration: number): Promise<void>;
+    private isVisible;
+    private filterSourceElements;
+    getPageSource(): Promise<SourceTree>;
+    getElementsOnScreen(): Promise<ScreenElement[]>;
+    openUrl(url: string): Promise<void>;
+    getScreenshot(): Promise<Buffer>;
+    swipe(direction: SwipeDirection): Promise<void>;
+    swipeFromCoordinate(x: number, y: number, direction: SwipeDirection, distance?: number): Promise<void>;
+    setOrientation(orientation: Orientation): Promise<void>;
+    getOrientation(): Promise<Orientation>;
+}

package/lib/webdriver-agent.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDriverAgent = void 0;
+const robot_1 = require("./robot");
+class WebDriverAgent {
+    host;
+    port;
+    constructor(host, port) {
+        this.host = host;
+        this.port = port;
+    }
+    async isRunning() {
+        const url = `http://${this.host}:${this.port}/status`;
+        try {
+            const response = await fetch(url);
+            const json = await response.json();
+            return response.status === 200 && json.value?.ready === true;
+        }
+        catch (error) {
+            // console.error(`Failed to connect to WebDriverAgent: ${error}`);
+            return false;
+        }
+    }
+    async createSession() {
+        const url = `http://${this.host}:${this.port}/session`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ capabilities: { alwaysMatch: { platformName: "iOS" } } }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new robot_1.ActionableError(`Failed to create WebDriver session: ${response.status} ${errorText}`);
+        }
+        const json = await response.json();
+        if (!json.value || !json.value.sessionId) {
+            throw new robot_1.ActionableError(`Invalid session response: ${JSON.stringify(json)}`);
+        }
+        return json.value.sessionId;
+    }
+    async deleteSession(sessionId) {
+        const url = `http://${this.host}:${this.port}/session/${sessionId}`;
+        const response = await fetch(url, { method: "DELETE" });
+        return response.json();
+    }
+    async withinSession(fn) {
+        const sessionId = await this.createSession();
+        const url = `http://${this.host}:${this.port}/session/${sessionId}`;
+        const result = await fn(url);
+        await this.deleteSession(sessionId);
+        return result;
+    }
+    async getScreenSize(sessionUrl) {
+        if (sessionUrl) {
+            const url = `${sessionUrl}/wda/screen`;
+            const response = await fetch(url);
+            const json = await response.json();
+            return {
+                width: json.value.screenSize.width,
+                height: json.value.screenSize.height,
+                scale: json.value.scale || 1,
+            };
+        }
+        else {
+            return this.withinSession(async (sessionUrlInner) => {
+                const url = `${sessionUrlInner}/wda/screen`;
+                const response = await fetch(url);
+                const json = await response.json();
+                return {
+                    width: json.value.screenSize.width,
+                    height: json.value.screenSize.height,
+                    scale: json.value.scale || 1,
+                };
+            });
+        }
+    }
+    async sendKeys(keys) {
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/wda/keys`;
+            await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ value: [keys] }),
+            });
+        });
+    }
+    async pressButton(button) {
+        const _map = {
+            "HOME": "home",
+            "VOLUME_UP": "volumeup",
+            "VOLUME_DOWN": "volumedown",
+        };
+        if (button === "ENTER") {
+            await this.sendKeys("\n");
+            return;
+        }
+        // Type assertion to check if button is a key of _map
+        if (!(button in _map)) {
+            throw new robot_1.ActionableError(`Button "${button}" is not supported`);
+        }
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/wda/pressButton`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    name: button,
+                }),
+            });
+            return response.json();
+        });
+    }
+    async tap(x, y) {
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/actions`;
+            await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    actions: [
+                        {
+                            type: "pointer",
+                            id: "finger1",
+                            parameters: { pointerType: "touch" },
+                            actions: [
+                                { type: "pointerMove", duration: 0, x, y },
+                                { type: "pointerDown", button: 0 },
+                                { type: "pause", duration: 100 },
+                                { type: "pointerUp", button: 0 }
+                            ]
+                        }
+                    ]
+                }),
+            });
+        });
+    }
+    async doubleTap(x, y) {
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/actions`;
+            await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    actions: [
+                        {
+                            type: "pointer",
+                            id: "finger1",
+                            parameters: { pointerType: "touch" },
+                            actions: [
+                                { type: "pointerMove", duration: 0, x, y },
+                                { type: "pointerDown", button: 0 },
+                                { type: "pause", duration: 50 },
+                                { type: "pointerUp", button: 0 },
+                                { type: "pause", duration: 100 },
+                                { type: "pointerDown", button: 0 },
+                                { type: "pause", duration: 50 },
+                                { type: "pointerUp", button: 0 }
+                            ]
+                        }
+                    ]
+                }),
+            });
+        });
+    }
+    async longPress(x, y, duration) {
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/actions`;
+            await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    actions: [
+                        {
+                            type: "pointer",
+                            id: "finger1",
+                            parameters: { pointerType: "touch" },
+                            actions: [
+                                { type: "pointerMove", duration: 0, x, y },
+                                { type: "pointerDown", button: 0 },
+                                { type: "pause", duration },
+                                { type: "pointerUp", button: 0 }
+                            ]
+                        }
+                    ]
+                }),
+            });
+        });
+    }
+    isVisible(rect) {
+        return rect.x >= 0 && rect.y >= 0;
+    }
+    filterSourceElements(source) {
+        const output = [];
+        const acceptedTypes = ["TextField", "Button", "Switch", "Icon", "SearchField", "StaticText", "Image"];
+        if (acceptedTypes.includes(source.type)) {
+            if (source.isVisible === "1" && this.isVisible(source.rect)) {
+                if (source.label !== null || source.name !== null || source.rawIdentifier !== null) {
+                    output.push({
+                        type: source.type,
+                        label: source.label,
+                        name: source.name,
+                        value: source.value,
+                        identifier: source.rawIdentifier,
+                        rect: {
+                            x: source.rect.x,
+                            y: source.rect.y,
+                            width: source.rect.width,
+                            height: source.rect.height,
+                        },
+                    });
+                }
+            }
+        }
+        if (source.children) {
+            for (const child of source.children) {
+                output.push(...this.filterSourceElements(child));
+            }
+        }
+        return output;
+    }
+    async getPageSource() {
+        const url = `http://${this.host}:${this.port}/source/?format=json`;
+        const response = await fetch(url);
+        const json = await response.json();
+        return json;
+    }
+    async getElementsOnScreen() {
+        const source = await this.getPageSource();
+        return this.filterSourceElements(source.value);
+    }
+    async openUrl(url) {
+        await this.withinSession(async (sessionUrl) => {
+            await fetch(`${sessionUrl}/url`, {
+                method: "POST",
+                body: JSON.stringify({ url }),
+            });
+        });
+    }
+    async getScreenshot() {
+        const url = `http://${this.host}:${this.port}/screenshot`;
+        const response = await fetch(url);
+        const json = await response.json();
+        return Buffer.from(json.value, "base64");
+    }
+    async swipe(direction) {
+        await this.withinSession(async (sessionUrl) => {
+            const screenSize = await this.getScreenSize(sessionUrl);
+            let x0, y0, x1, y1;
+            // Use 60% of the width/height for swipe distance
+            const verticalDistance = Math.floor(screenSize.height * 0.6);
+            const horizontalDistance = Math.floor(screenSize.width * 0.6);
+            const centerX = Math.floor(screenSize.width / 2);
+            const centerY = Math.floor(screenSize.height / 2);
+            switch (direction) {
+                case "up":
+                    x0 = x1 = centerX;
+                    y0 = centerY + Math.floor(verticalDistance / 2);
+                    y1 = centerY - Math.floor(verticalDistance / 2);
+                    break;
+                case "down":
+                    x0 = x1 = centerX;
+                    y0 = centerY - Math.floor(verticalDistance / 2);
+                    y1 = centerY + Math.floor(verticalDistance / 2);
+                    break;
+                case "left":
+                    y0 = y1 = centerY;
+                    x0 = centerX + Math.floor(horizontalDistance / 2);
+                    x1 = centerX - Math.floor(horizontalDistance / 2);
+                    break;
+                case "right":
+                    y0 = y1 = centerY;
+                    x0 = centerX - Math.floor(horizontalDistance / 2);
+                    x1 = centerX + Math.floor(horizontalDistance / 2);
+                    break;
+                default:
+                    throw new robot_1.ActionableError(`Swipe direction "${direction}" is not supported`);
+            }
+            const url = `${sessionUrl}/actions`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    actions: [
+                        {
+                            type: "pointer",
+                            id: "finger1",
+                            parameters: { pointerType: "touch" },
+                            actions: [
+                                { type: "pointerMove", duration: 0, x: x0, y: y0 },
+                                { type: "pointerDown", button: 0 },
+                                { type: "pointerMove", duration: 1000, x: x1, y: y1 },
+                                { type: "pointerUp", button: 0 }
+                            ]
+                        }
+                    ]
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new robot_1.ActionableError(`WebDriver actions request failed: ${response.status} ${errorText}`);
+            }
+            // Clear actions to ensure they complete
+            await fetch(`${sessionUrl}/actions`, {
+                method: "DELETE",
+            });
+        });
+    }
+    async swipeFromCoordinate(x, y, direction, distance = 400) {
+        await this.withinSession(async (sessionUrl) => {
+            // Use simple coordinates like the working swipe method
+            const x0 = x;
+            const y0 = y;
+            let x1 = x;
+            let y1 = y;
+            // Calculate target position based on direction and distance
+            switch (direction) {
+                case "up":
+                    y1 = y - distance; // Move up by specified distance
+                    break;
+                case "down":
+                    y1 = y + distance; // Move down by specified distance
+                    break;
+                case "left":
+                    x1 = x - distance; // Move left by specified distance
+                    break;
+                case "right":
+                    x1 = x + distance; // Move right by specified distance
+                    break;
+                default:
+                    throw new robot_1.ActionableError(`Swipe direction "${direction}" is not supported`);
+            }
+            const url = `${sessionUrl}/actions`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    actions: [
+                        {
+                            type: "pointer",
+                            id: "finger1",
+                            parameters: { pointerType: "touch" },
+                            actions: [
+                                { type: "pointerMove", duration: 0, x: x0, y: y0 },
+                                { type: "pointerDown", button: 0 },
+                                { type: "pointerMove", duration: 1000, x: x1, y: y1 },
+                                { type: "pointerUp", button: 0 }
+                            ]
+                        }
+                    ]
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new robot_1.ActionableError(`WebDriver actions request failed: ${response.status} ${errorText}`);
+            }
+            // Clear actions to ensure they complete
+            await fetch(`${sessionUrl}/actions`, {
+                method: "DELETE",
+            });
+        });
+    }
+    async setOrientation(orientation) {
+        await this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/orientation`;
+            await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    orientation: orientation.toUpperCase()
+                })
+            });
+        });
+    }
+    async getOrientation() {
+        return this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/orientation`;
+            const response = await fetch(url);
+            const json = await response.json();
+            return json.value.toLowerCase();
+        });
+    }
+}
+exports.WebDriverAgent = WebDriverAgent;
+//# sourceMappingURL=webdriver-agent.js.map