@nbakka/mcp-appium 1.0.28 → 2.0.1

package/lib/ios.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IosManager = exports.IosRobot = void 0;
+const path_1 = __importDefault(require("path"));
+const os_1 = require("os");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const net_1 = require("net");
+const webdriver_agent_1 = require("./webdriver-agent");
+const robot_1 = require("./robot");
+const WDA_PORT = 8100;
+const IOS_TUNNEL_PORT = 60105;
+const getGoIosPath = () => {
+    if (process.env.GO_IOS_PATH) {
+        return process.env.GO_IOS_PATH;
+    }
+    // fallback to go-ios in PATH via `npm install -g go-ios`
+    return "ios";
+};
+class IosRobot {
+    deviceId;
+    constructor(deviceId) {
+        this.deviceId = deviceId;
+    }
+    isListeningOnPort(port) {
+        return new Promise((resolve, reject) => {
+            const client = new net_1.Socket();
+            client.connect(port, "localhost", () => {
+                client.destroy();
+                resolve(true);
+            });
+            client.on("error", (err) => {
+                resolve(false);
+            });
+        });
+    }
+    async isTunnelRunning() {
+        return await this.isListeningOnPort(IOS_TUNNEL_PORT);
+    }
+    async isWdaForwardRunning() {
+        return await this.isListeningOnPort(WDA_PORT);
+    }
+    async assertTunnelRunning() {
+        if (await this.isTunnelRequired()) {
+            if (!(await this.isTunnelRunning())) {
+                throw new robot_1.ActionableError("iOS tunnel is not running, please see https://github.com/mobile-next/mobile-mcp/wiki/");
+            }
+        }
+    }
+    async wda() {
+        await this.assertTunnelRunning();
+        if (!(await this.isWdaForwardRunning())) {
+            throw new robot_1.ActionableError("Port forwarding to WebDriverAgent is not running (tunnel okay), please see https://github.com/mobile-next/mobile-mcp/wiki/");
+        }
+        const wda = new webdriver_agent_1.WebDriverAgent("localhost", WDA_PORT);
+        if (!(await wda.isRunning())) {
+            throw new robot_1.ActionableError("WebDriverAgent is not running on device (tunnel okay, port forwarding okay), please see https://github.com/mobile-next/mobile-mcp/wiki/");
+        }
+        return wda;
+    }
+    async ios(...args) {
+        return (0, child_process_1.execFileSync)(getGoIosPath(), ["--udid", this.deviceId, ...args], {}).toString();
+    }
+    async getIosVersion() {
+        const output = await this.ios("info");
+        const json = JSON.parse(output);
+        return json.ProductVersion;
+    }
+    async isTunnelRequired() {
+        const version = await this.getIosVersion();
+        const args = version.split(".");
+        return parseInt(args[0], 10) >= 17;
+    }
+    async getScreenSize() {
+        const wda = await this.wda();
+        return await wda.getScreenSize();
+    }
+    async swipe(direction) {
+        const wda = await this.wda();
+        await wda.swipe(direction);
+    }
+    async listApps() {
+        await this.assertTunnelRunning();
+        const output = await this.ios("apps", "--all", "--list");
+        return output
+            .split("\n")
+            .map(line => {
+            const [packageName, appName] = line.split(" ");
+            return {
+                packageName,
+                appName,
+            };
+        });
+    }
+    async launchApp(packageName) {
+        await this.assertTunnelRunning();
+        await this.ios("launch", packageName);
+    }
+    async terminateApp(packageName) {
+        await this.assertTunnelRunning();
+        await this.ios("kill", packageName);
+    }
+    async openUrl(url) {
+        const wda = await this.wda();
+        await wda.openUrl(url);
+    }
+    async sendKeys(text) {
+        const wda = await this.wda();
+        await wda.sendKeys(text);
+    }
+    async pressButton(button) {
+        const wda = await this.wda();
+        await wda.pressButton(button);
+    }
+    async tap(x, y) {
+        const wda = await this.wda();
+        await wda.tap(x, y);
+    }
+    async getElementsOnScreen() {
+        const wda = await this.wda();
+        return await wda.getElementsOnScreen();
+    }
+    async getScreenshot() {
+        await this.assertTunnelRunning();
+        const tmpFilename = path_1.default.join((0, os_1.tmpdir)(), `screenshot-${(0, crypto_1.randomBytes)(8).toString("hex")}.png`);
+        await this.ios("screenshot", "--output", tmpFilename);
+        const buffer = (0, fs_1.readFileSync)(tmpFilename);
+        (0, fs_1.unlinkSync)(tmpFilename);
+        return buffer;
+    }
+    async setOrientation(orientation) {
+        const wda = await this.wda();
+        await wda.setOrientation(orientation);
+    }
+    async getOrientation() {
+        const wda = await this.wda();
+        return await wda.getOrientation();
+    }
+}
+exports.IosRobot = IosRobot;
+class IosManager {
+    async isGoIosInstalled() {
+        try {
+            const output = (0, child_process_1.execFileSync)(getGoIosPath(), ["version"], { stdio: ["pipe", "pipe", "ignore"] }).toString();
+            const json = JSON.parse(output);
+            return json.version !== undefined && (json.version.startsWith("v") || json.version === "local-build");
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async getDeviceName(deviceId) {
+        const output = (0, child_process_1.execFileSync)(getGoIosPath(), ["info", "--udid", deviceId]).toString();
+        const json = JSON.parse(output);
+        return json.DeviceName;
+    }
+    async listDevices() {
+        if (!(await this.isGoIosInstalled())) {
+            console.error("go-ios is not installed, no physical iOS devices can be detected");
+            return [];
+        }
+        const output = (0, child_process_1.execFileSync)(getGoIosPath(), ["list"]).toString();
+        const json = JSON.parse(output);
+        const devices = json.deviceList.map(async (device) => ({
+            deviceId: device,
+            deviceName: await this.getDeviceName(device),
+        }));
+        return Promise.all(devices);
+    }
+}
+exports.IosManager = IosManager;

package/lib/iphone-simulator.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimctlManager = exports.Simctl = void 0;
+const child_process_1 = require("child_process");
+const webdriver_agent_1 = require("./webdriver-agent");
+const robot_1 = require("./robot");
+const TIMEOUT = 30000;
+const WDA_PORT = 8100;
+const MAX_BUFFER_SIZE = 1024 * 1024 * 4;
+class Simctl {
+    simulatorUuid;
+    constructor(simulatorUuid) {
+        this.simulatorUuid = simulatorUuid;
+    }
+    async wda() {
+        const wda = new webdriver_agent_1.WebDriverAgent("localhost", WDA_PORT);
+        if (!(await wda.isRunning())) {
+            throw new robot_1.ActionableError("WebDriverAgent is not running on simulator, please see https://github.com/mobile-next/mobile-mcp/wiki/");
+        }
+        return wda;
+    }
+    simctl(...args) {
+        return (0, child_process_1.execFileSync)("xcrun", ["simctl", ...args], {
+            timeout: TIMEOUT,
+            maxBuffer: MAX_BUFFER_SIZE,
+        });
+    }
+    async getScreenshot() {
+        return this.simctl("io", this.simulatorUuid, "screenshot", "-");
+    }
+    async openUrl(url) {
+        const wda = await this.wda();
+        await wda.openUrl(url);
+        // alternative: this.simctl("openurl", this.simulatorUuid, url);
+    }
+    async launchApp(packageName) {
+        this.simctl("launch", this.simulatorUuid, packageName);
+    }
+    async terminateApp(packageName) {
+        this.simctl("terminate", this.simulatorUuid, packageName);
+    }
+    static parseIOSAppData(inputText) {
+        const result = [];
+        let ParseState;
+        (function (ParseState) {
+            ParseState[ParseState["LOOKING_FOR_APP"] = 0] = "LOOKING_FOR_APP";
+            ParseState[ParseState["IN_APP"] = 1] = "IN_APP";
+            ParseState[ParseState["IN_PROPERTY"] = 2] = "IN_PROPERTY";
+        })(ParseState || (ParseState = {}));
+        let state = ParseState.LOOKING_FOR_APP;
+        let currentApp = {};
+        let appIdentifier = "";
+        const lines = inputText.split("\n");
+        for (let line of lines) {
+            line = line.trim();
+            if (line === "") {
+                continue;
+            }
+            switch (state) {
+                case ParseState.LOOKING_FOR_APP:
+                    // look for app identifier pattern: "com.example.app" = {
+                    const appMatch = line.match(/^"?([^"=]+)"?\s*=\s*\{/);
+                    if (appMatch) {
+                        appIdentifier = appMatch[1].trim();
+                        currentApp = {
+                            CFBundleIdentifier: appIdentifier,
+                        };
+                        state = ParseState.IN_APP;
+                    }
+                    break;
+                case ParseState.IN_APP:
+                    if (line === "};") {
+                        result.push(currentApp);
+                        currentApp = {};
+                        state = ParseState.LOOKING_FOR_APP;
+                    }
+                    else {
+                        // look for property: PropertyName = Value;
+                        const propertyMatch = line.match(/^([^=]+)\s*=\s*(.+?);\s*$/);
+                        if (propertyMatch) {
+                            const propName = propertyMatch[1].trim();
+                            let propValue = propertyMatch[2].trim();
+                            // remove quotes if present (they're optional)
+                            if (propValue.startsWith('"') && propValue.endsWith('"')) {
+                                propValue = propValue.substring(1, propValue.length - 1);
+                            }
+                            // add property to current app
+                            currentApp[propName] = propValue;
+                        }
+                        else if (line.endsWith("{")) {
+                            // nested property like GroupContainers = {
+                            state = ParseState.IN_PROPERTY;
+                        }
+                    }
+                    break;
+                case ParseState.IN_PROPERTY:
+                    if (line === "};") {
+                        // end of nested property
+                        state = ParseState.IN_APP;
+                    }
+                    // skip content of nested properties, we don't care of those right now
+                    break;
+            }
+        }
+        return result;
+    }
+    async listApps() {
+        const text = this.simctl("listapps", this.simulatorUuid).toString();
+        const apps = Simctl.parseIOSAppData(text);
+        return apps.map(app => ({
+            packageName: app.CFBundleIdentifier,
+            appName: app.CFBundleDisplayName,
+        }));
+    }
+    async getScreenSize() {
+        const wda = await this.wda();
+        return wda.getScreenSize();
+    }
+    async sendKeys(keys) {
+        const wda = await this.wda();
+        return wda.sendKeys(keys);
+    }
+    async swipe(direction) {
+        const wda = await this.wda();
+        return wda.swipe(direction);
+    }
+    async tap(x, y) {
+        const wda = await this.wda();
+        return wda.tap(x, y);
+    }
+    async pressButton(button) {
+        const wda = await this.wda();
+        return wda.pressButton(button);
+    }
+    async getElementsOnScreen() {
+        const wda = await this.wda();
+        return wda.getElementsOnScreen();
+    }
+    async setOrientation(orientation) {
+        const wda = await this.wda();
+        return wda.setOrientation(orientation);
+    }
+    async getOrientation() {
+        const wda = await this.wda();
+        return wda.getOrientation();
+    }
+}
+exports.Simctl = Simctl;
+class SimctlManager {
+    listSimulators() {
+        // detect if this is a mac
+        if (process.platform !== "darwin") {
+            // don't even try to run xcrun
+            return [];
+        }
+        try {
+            const text = (0, child_process_1.execFileSync)("xcrun", ["simctl", "list", "devices", "-j"]).toString();
+            const json = JSON.parse(text);
+            return Object.values(json.devices).flatMap(device => {
+                return device.map(d => {
+                    return {
+                        name: d.name,
+                        uuid: d.udid,
+                        state: d.state,
+                    };
+                });
+            });
+        }
+        catch (error) {
+            console.error("Error listing simulators", error);
+            return [];
+        }
+    }
+    listBootedSimulators() {
+        return this.listSimulators()
+            .filter(simulator => simulator.state === "Booted");
+    }
+    getSimulator(uuid) {
+        return new Simctl(uuid);
+    }
+}
+exports.SimctlManager = SimctlManager;

package/lib/logger.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = exports.trace = void 0;
+const fs_1 = require("fs");
+const writeLog = (message) => {
+    if (process.env.LOG_FILE) {
+        const logfile = process.env.LOG_FILE;
+        const timestamp = new Date().toISOString();
+        const levelStr = "INFO";
+        const logMessage = `[${timestamp}] ${levelStr} ${message}`;
+        (0, fs_1.appendFileSync)(logfile, logMessage + "\n");
+    }
+    console.error(message);
+};
+const trace = (message) => {
+    writeLog(message);
+};
+exports.trace = trace;
+const error = (message) => {
+    writeLog(message);
+};
+exports.error = error;

package/lib/png.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PNG = void 0;
+class PNG {
+    buffer;
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    getDimensions() {
+        const pngSignature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+        if (!this.buffer.subarray(0, 8).equals(pngSignature)) {
+            throw new Error("Not a valid PNG file");
+        }
+        const width = this.buffer.readUInt32BE(16);
+        const height = this.buffer.readUInt32BE(20);
+        return { width, height };
+    }
+}
+exports.PNG = PNG;

package/lib/robot.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionableError = void 0;
+class ActionableError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ActionableError = ActionableError;