@mobilenext/mobile-mcp 0.0.10 → 0.0.11

package/README.md

@@ -3,6 +3,9 @@
 This is a [Model Context Protocol (MCP) server](https://github.com/modelcontextprotocol) that enables scalable mobile automation through a platform-agnostic interface, eliminating the need for distinct iOS or Android knowledge.
 This server allows Agents and LLMs to interact with native iOS/Android applications and devices through structured accessibility snapshots or coordinate-based taps based on screenshots. 
 
+https://github.com/user-attachments/assets/c4e89c4f-cc71-4424-8184-bdbc8c638fa1
+
+
 <p align="center">
   <a href="https://www.npmjs.com/package/@mobilenext/mobile-mcp">
     <img src="https://img.shields.io/badge/npm-@mobilenext/mobile--mcp-red" alt="npm">
@@ -18,6 +21,7 @@ This server allows Agents and LLMs to interact with native iOS/Android applicati
     </a>
 </p>
 
+
 ### 🚀 Mobile MCP Roadmap: Building the Future of Mobile
 
 Join us on our journey as we continuously enhance Mobile MCP! 
@@ -46,14 +50,16 @@ How we help to scale mobile automation:
 ## Mobile MCP Architecture
 
 <p align="center">
-    <a href="https://raw.githubusercontent.com/mobile-next/mobile-next-assets/refs/heads/main/mobile-mcp-arch.png">
-        <img alt="mobile-mcp" src="https://raw.githubusercontent.com/mobile-next/mobile-next-assets/refs/heads/main/mobile-mcp-arch.png" width="600">
+    <a href="https://raw.githubusercontent.com/mobile-next/mobile-next-assets/refs/heads/main/mobile-mcp-arch-1.png">
+        <img alt="mobile-mcp" src="https://raw.githubusercontent.com/mobile-next/mobile-next-assets/refs/heads/main/mobile-mcp-arch-1.png" width="600">
     </a>
 </p>
 
 
 
-## How to install
+## Installation and configuration
+
+[Detailed guide for Claude Desktop](https://modelcontextprotocol.io/quickstart/user)
 
 ```json
 {
@@ -67,7 +73,8 @@ How we help to scale mobile automation:
 
 ```
 
-[From Claude Code:](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview)
+[Claude Code:](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview)
+
 ```
 claude mcp add mobile -- npx -y @mobilenext/mobile-mcp@latest ⁠
 ```
@@ -112,6 +119,11 @@ The commands and tools support both accessibility-based locators (preferred) and
 - **Parameters:**
   - `appPath` (string): Path or URL to the app file (e.g., .apk for Android, .ipa/.app for iOS)
 
+## mobile_list_apps
+- **Description:** List all the installed apps on the device
+- **Parameters:**
+  - `bundleId` (string): The application's unique bundle/package identifier like: com.google.android.keep	 or com.apple.mobilenotes )
+
 ## mobile_launch_app
 - **Description:** Launches the specified app on the device/emulator
 - **Parameters:**
@@ -120,7 +132,21 @@ The commands and tools support both accessibility-based locators (preferred) and
 ## mobile_terminate_app
 - **Description:** Terminates a running application
 - **Parameters:**
-  - `bundleId` (string): The application's bundle/package identifier
+  - `packageName` (string): Based on the application's bundle/package identifier calls am force stop or kills the app based on pid.
+ 
+## mobile_get_screen_size
+- **Description:** Get the screen size of the mobile device in pixels
+- **Parameters:** None
+
+## mobile_click_on_screen_at_coordinates
+- **Description:** Taps on specified screen coordinates based on coordinates. 
+- **Parameters:**
+  - `x` (number): X-coordinate
+  - `y` (number): Y-coordinate
+ 
+## mobile_list_elements_on_screen
+- **Description:** List elements on screen and their coordinates, with display text or accessibility label.
+- **Parameters:** None
 
 ## mobile_element_tap
 - **Description:** Taps on a UI element identified by accessibility locator
@@ -133,9 +159,18 @@ The commands and tools support both accessibility-based locators (preferred) and
 - **Parameters:**
   - `x` (number): X-coordinate
   - `y` (number): Y-coordinate
+ 
+## mobile_press_button
+- **Description:** Press a button on device (home, back, volume, enter, power button.)
+- **Parameters:** None
 
-## mobile_element_send_keys
-- **Description:** Types text into a UI element (e.g., TextField)
+## mobile_open_url
+- **Description:** Open a URL in browser on device
+- **Parameters:**
+  - `url` (string): The URL to be opened (e.g., "https://example.com").
+
+## mobile_type_text
+- **Description:** Types text into a focused UI element (e.g., TextField, SearchField)
 - **Parameters:**
   - `element` (string): Human-readable element description
   - `ref` (string): Accessibility/automation ID of the element
@@ -182,3 +217,11 @@ The commands and tools support both accessibility-based locators (preferred) and
 - **Parameters:** None
 
 
+# Thanks to all contributors ❤️
+
+### We appreciate everyone who has helped improve this project. 
+
+  <a href = "https://github.com/mobile-next/mobile-mcp/graphs/contributors">
+   <img src = "https://contrib.rocks/image?repo=mobile-next/mobile-mcp"/>
+ </a>
+

package/lib/android.js

@@ -32,140 +32,167 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listApps = exports.takeScreenshot = exports.swipe = exports.getElementsOnScreen = exports.getScreenSize = exports.resolveLaunchableActivities = exports.getConnectedDevices = void 0;
+exports.getConnectedDevices = exports.AndroidRobot = void 0;
 const child_process_1 = require("child_process");
 const xml = __importStar(require("fast-xml-parser"));
-const fs_1 = require("fs");
-const getConnectedDevices = () => {
-    return (0, child_process_1.execSync)(`adb devices`)
-        .toString()
-        .split("\n")
-        .filter(line => !line.startsWith("List of devices attached"))
-        .filter(line => line.trim() !== "");
-};
-exports.getConnectedDevices = getConnectedDevices;
-const resolveLaunchableActivities = (packageName) => {
-    return (0, child_process_1.execSync)(`adb shell cmd package resolve-activity ${packageName}`)
-        .toString()
-        .split("\n")
-        .map(line => line.trim())
-        .filter(line => line.startsWith("name="))
-        .map(line => line.substring("name=".length));
-};
-exports.resolveLaunchableActivities = resolveLaunchableActivities;
-const getScreenSize = () => {
-    const screenSize = (0, child_process_1.execSync)("adb shell wm size")
-        .toString()
-        .split(" ")
-        .pop();
-    if (!screenSize) {
-        throw new Error("Failed to get screen size");
+const path_1 = __importDefault(require("path"));
+class AndroidRobot {
+    deviceId;
+    constructor(deviceId) {
+        this.deviceId = deviceId;
     }
-    const [width, height] = screenSize.split("x").map(Number);
-    return [width, height];
-};
-exports.getScreenSize = getScreenSize;
-const collectElements = (node, screenSize) => {
-    const elements = [];
-    const getCoordinates = (element) => {
-        const bounds = String(element.bounds);
-        const [, left, top, right, bottom] = bounds.match(/^\[(\d+),(\d+)\]\[(\d+),(\d+)\]$/)?.map(Number) || [];
-        return { left, top, right, bottom };
-    };
-    const getCenter = (coordinates) => {
-        return {
-            x: Math.floor((coordinates.left + coordinates.right) / 2),
-            y: Math.floor((coordinates.top + coordinates.bottom) / 2),
+    async getScreenSize() {
+        const screenSize = (0, child_process_1.execSync)(`adb -s ${this.deviceId} shell wm size`)
+            .toString()
+            .split(" ")
+            .pop();
+        if (!screenSize) {
+            throw new Error("Failed to get screen size");
+        }
+        const [width, height] = screenSize.split("x").map(Number);
+        return { width, height };
+    }
+    adb(...args) {
+        let executable = "adb";
+        if (process.env.ANDROID_HOME) {
+            executable = path_1.default.join(process.env.ANDROID_HOME, "platform-tools", "adb");
+        }
+        return (0, child_process_1.execFileSync)(executable, ["-s", this.deviceId, ...args], {
+            maxBuffer: 1024 * 1024 * 4,
+            timeout: 30000,
+        });
+    }
+    async listApps() {
+        const result = this.adb("shell", "cmd", "package", "query-activities", "-a", "android.intent.action.MAIN", "-c", "android.intent.category.LAUNCHER")
+            .toString()
+            .split("\n")
+            .map(line => line.trim())
+            .filter(line => line.startsWith("packageName="))
+            .map(line => line.substring("packageName=".length))
+            .filter((value, index, self) => self.indexOf(value) === index);
+        return result;
+    }
+    async launchApp(packageName) {
+        this.adb("shell", "monkey", "-p", packageName, "-c", "android.intent.category.LAUNCHER", "1");
+    }
+    async swipe(direction) {
+        const screenSize = await this.getScreenSize();
+        const centerX = screenSize.width >> 1;
+        // const centerY = screenSize[1] >> 1;
+        let x0, y0, x1, y1;
+        switch (direction) {
+            case "up":
+                x0 = x1 = centerX;
+                y0 = Math.floor(screenSize.height * 0.80);
+                y1 = Math.floor(screenSize.height * 0.20);
+                break;
+            case "down":
+                x0 = x1 = centerX;
+                y0 = Math.floor(screenSize.height * 0.20);
+                y1 = Math.floor(screenSize.height * 0.80);
+                break;
+            default:
+                throw new Error(`Swipe direction "${direction}" is not supported`);
+        }
+        this.adb("shell", "input", "swipe", `${x0}`, `${y0}`, `${x1}`, `${y1}`, "1000");
+    }
+    async getScreenshot() {
+        return this.adb("shell", "screencap", "-p");
+    }
+    collectElements(node, screenSize) {
+        const elements = [];
+        const getCoordinates = (element) => {
+            const bounds = String(element.bounds);
+            const [, left, top, right, bottom] = bounds.match(/^\[(\d+),(\d+)\]\[(\d+),(\d+)\]$/)?.map(Number) || [];
+            return { left, top, right, bottom };
         };
-    };
-    const normalizeCoordinates = (coordinates, screenSize) => {
-        return {
-            x: Number((coordinates.x / screenSize[0]).toFixed(3)),
-            y: Number((coordinates.y / screenSize[1]).toFixed(3)),
+        const getCenter = (coordinates) => {
+            return {
+                x: Math.floor((coordinates.left + coordinates.right) / 2),
+                y: Math.floor((coordinates.top + coordinates.bottom) / 2),
+            };
         };
-    };
-    if (node.node) {
-        if (Array.isArray(node.node)) {
-            for (const childNode of node.node) {
-                elements.push(...collectElements(childNode, screenSize));
+        const normalizeCoordinates = (coordinates, screenSize) => {
+            return {
+                x: Number((coordinates.x / screenSize.width).toFixed(3)),
+                y: Number((coordinates.y / screenSize.height).toFixed(3)),
+            };
+        };
+        if (node.node) {
+            if (Array.isArray(node.node)) {
+                for (const childNode of node.node) {
+                    elements.push(...this.collectElements(childNode, screenSize));
+                }
             }
+            else {
+                elements.push(...this.collectElements(node.node, screenSize));
+            }
+        }
+        if (node.text) {
+            elements.push({
+                "text": node.text,
+                "coordinates": normalizeCoordinates(getCenter(getCoordinates(node)), screenSize),
+            });
         }
-        else {
-            elements.push(...collectElements(node.node, screenSize));
+        if (node["content-desc"]) {
+            elements.push({
+                "text": node["content-desc"],
+                "coordinates": normalizeCoordinates(getCenter(getCoordinates(node)), screenSize),
+            });
         }
+        return elements;
     }
-    if (node.text) {
-        elements.push({
-            "text": node.text,
-            "coordinates": normalizeCoordinates(getCenter(getCoordinates(node)), screenSize),
+    async getElementsOnScreen() {
+        const dump = this.adb("exec-out", "uiautomator", "dump", "/dev/tty");
+        const parser = new xml.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: ""
         });
+        const parsedXml = parser.parse(dump);
+        const hierarchy = parsedXml.hierarchy;
+        const screenSize = await this.getScreenSize();
+        const elements = this.collectElements(hierarchy.node, screenSize);
+        return elements;
     }
-    if (node["content-desc"]) {
-        elements.push({
-            "text": node["content-desc"],
-            "coordinates": normalizeCoordinates(getCenter(getCoordinates(node)), screenSize),
-        });
+    async terminateApp(packageName) {
+        this.adb("shell", "am", "force-stop", packageName);
     }
-    return elements;
-};
-const getElementsOnScreen = () => {
-    const dump = (0, child_process_1.execSync)(`adb exec-out uiautomator dump /dev/tty`);
-    const parser = new xml.XMLParser({
-        ignoreAttributes: false,
-        attributeNamePrefix: ""
-    });
-    const parsedXml = parser.parse(dump);
-    const hierarchy = parsedXml.hierarchy;
-    const screenSize = (0, exports.getScreenSize)();
-    const elements = collectElements(hierarchy, screenSize);
-    return elements;
-};
-exports.getElementsOnScreen = getElementsOnScreen;
-const swipe = (direction) => {
-    const screenSize = (0, exports.getScreenSize)();
-    const centerX = screenSize[0] >> 1;
-    // const centerY = screenSize[1] >> 1;
-    let x0, y0, x1, y1;
-    switch (direction) {
-        case "up":
-            x0 = x1 = centerX;
-            y0 = Math.floor(screenSize[1] * 0.80);
-            y1 = Math.floor(screenSize[1] * 0.20);
-            break;
-        case "down":
-            x0 = x1 = centerX;
-            y0 = Math.floor(screenSize[1] * 0.20);
-            y1 = Math.floor(screenSize[1] * 0.80);
-            break;
-        default:
-            throw new Error(`Swipe direction "${direction}" is not supported`);
+    async openUrl(url) {
+        this.adb("shell", "am", "start", "-a", "android.intent.action.VIEW", "-d", url);
     }
-    (0, child_process_1.execSync)(`adb shell input swipe ${x0} ${y0} ${x1} ${y1} 1000`);
-};
-exports.swipe = swipe;
-const takeScreenshot = async () => {
-    const randomFilename = `screenshot-${Date.now()}.png`;
-    // take screenshot and save on device
-    const remoteFilename = `/sdcard/Download/${randomFilename}`;
-    (0, child_process_1.execSync)(`adb shell screencap -p ${remoteFilename}`);
-    // pull the file locally
-    const localFilename = `/tmp/${randomFilename}`;
-    (0, child_process_1.execSync)(`adb pull ${remoteFilename} ${localFilename}`);
-    (0, child_process_1.execSync)(`adb shell rm ${remoteFilename}`);
-    const screenshot = (0, fs_1.readFileSync)(localFilename);
-    (0, fs_1.unlinkSync)(localFilename);
-    return screenshot;
-};
-exports.takeScreenshot = takeScreenshot;
-const listApps = () => {
-    const result = (0, child_process_1.execSync)(`adb shell cmd package query-activities -a android.intent.action.MAIN -c android.intent.category.LAUNCHER`)
+    async sendKeys(text) {
+        // adb shell requires some escaping
+        const _text = text.replace(/ /g, "\\ ");
+        this.adb("shell", "input", "text", _text);
+    }
+    async pressButton(button) {
+        const _map = {
+            "BACK": "KEYCODE_BACK",
+            "HOME": "KEYCODE_HOME",
+            "VOLUME_UP": "KEYCODE_VOLUME_UP",
+            "VOLUME_DOWN": "KEYCODE_VOLUME_DOWN",
+            "ENTER": "KEYCODE_ENTER",
+        };
+        if (!_map[button]) {
+            throw new Error(`Button "${button}" is not supported`);
+        }
+        this.adb("shell", "input", "keyevent", _map[button]);
+    }
+    async tap(x, y) {
+        this.adb("shell", "input", "tap", `${x}`, `${y}`);
+    }
+}
+exports.AndroidRobot = AndroidRobot;
+const getConnectedDevices = () => {
+    return (0, child_process_1.execSync)(`adb devices`)
         .toString()
         .split("\n")
-        .map(line => line.trim())
-        .filter(line => line.startsWith("packageName="))
-        .map(line => line.substring("packageName=".length))
-        .filter((value, index, self) => self.indexOf(value) === index);
-    return result;
+        .filter(line => !line.startsWith("List of devices attached"))
+        .filter(line => line.trim() !== "")
+        .map(line => line.split("\t")[0]);
 };
-exports.listApps = listApps;
+exports.getConnectedDevices = getConnectedDevices;

package/lib/ios.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IosManager = exports.IosRobot = void 0;
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const webdriver_agent_1 = require("./webdriver-agent");
+class IosRobot {
+    deviceId;
+    wda;
+    constructor(deviceId) {
+        this.deviceId = deviceId;
+        this.wda = new webdriver_agent_1.WebDriverAgent("localhost", 8100);
+    }
+    async ios(...args) {
+        return (0, child_process_1.execFileSync)("ios", ["--udid", this.deviceId, ...args], {}).toString();
+    }
+    async getScreenSize() {
+        return await this.wda.getScreenSize();
+    }
+    swipe(direction) {
+        return Promise.resolve();
+    }
+    async listApps() {
+        const output = await this.ios("apps", "--all", "--list");
+        return output
+            .split("\n")
+            .map(line => line.split(" ")[0]);
+    }
+    async launchApp(packageName) {
+        await this.ios("launch", packageName);
+    }
+    async terminateApp(packageName) {
+        await this.ios("kill", packageName);
+    }
+    async openUrl(url) {
+        await this.wda.withinSession(async (sessionUrl) => {
+            await fetch(`${sessionUrl}/url`, {
+                method: "POST",
+                body: JSON.stringify({ url }),
+            });
+        });
+    }
+    async sendKeys(text) {
+        await this.wda.sendKeys(text);
+    }
+    async pressButton(button) {
+        await this.wda.pressButton(button);
+    }
+    async tap(x, y) {
+        await this.wda.tap(x, y);
+    }
+    async getElementsOnScreen() {
+        return await this.wda.getElementsOnScreen();
+    }
+    async getScreenshot() {
+        await this.ios("screenshot", "--output", "screenshot.png");
+        const buffer = (0, fs_1.readFileSync)("screenshot.png");
+        (0, fs_1.unlinkSync)("screenshot.png");
+        return buffer;
+    }
+}
+exports.IosRobot = IosRobot;
+class IosManager {
+    async listDevices() {
+        const output = (0, child_process_1.execSync)("ios list").toString();
+        const json = JSON.parse(output);
+        return json.deviceList;
+    }
+}
+exports.IosManager = IosManager;
+async function main() {
+    const ios = new IosRobot("4C07ED7E-AE81-412E-8AA9-1061EED59DFA");
+    const before = +new Date();
+    console.dir(await ios.getElementsOnScreen(), { depth: null });
+    const after = +new Date();
+    console.log(`Time taken: ${after - before}ms`);
+    // await ios.pressButton("VOLUME_UP");
+}
+main().then();

package/lib/iphone-simulator.js

@@ -1,40 +1,173 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listApps = exports.launchApp = exports.openUrl = exports.getScreenshot = exports.getConnectedDevices = void 0;
+exports.SimctlManager = exports.Simctl = void 0;
 const child_process_1 = require("child_process");
-const getConnectedDevices = () => {
-    return (0, child_process_1.execSync)(`xcrun simctl list devices`)
-        .toString()
-        .split("\n")
-        .map(line => {
+const webdriver_agent_1 = require("./webdriver-agent");
+class Simctl {
+    simulatorUuid;
+    webDriverAgent;
+    constructor(simulatorUuid) {
+        this.simulatorUuid = simulatorUuid;
+        this.webDriverAgent = new webdriver_agent_1.WebDriverAgent("localhost", 8100);
+    }
+    simctl(...args) {
+        return (0, child_process_1.execFileSync)("xcrun", ["simctl", ...args], { maxBuffer: 1024 * 1024 * 4 });
+    }
+    async getScreenshot() {
+        return this.simctl("io", this.simulatorUuid, "screenshot", "-");
+    }
+    async openUrl(url) {
+        this.simctl("openurl", this.simulatorUuid, url);
+    }
+    async launchApp(packageName) {
+        this.simctl("launch", this.simulatorUuid, packageName);
+    }
+    async terminateApp(packageName) {
+        this.simctl("terminate", this.simulatorUuid, packageName);
+    }
+    parseIOSAppData(inputText) {
+        const result = [];
+        // Remove leading and trailing characters if needed
+        const cleanText = inputText.trim();
+        // Extract each app section
+        const appRegex = /"([^"]+)"\s+=\s+\{([^}]+)\};/g;
+        let appMatch;
+        while ((appMatch = appRegex.exec(cleanText)) !== null) {
+            // const bundleId = appMatch[1];
+            const appContent = appMatch[2];
+            const appInfo = {
+                GroupContainers: {},
+                SBAppTags: []
+            };
+            // parse simple key-value pairs
+            const keyValueRegex = /\s+(\w+)\s+=\s+([^;]+);/g;
+            let keyValueMatch;
+            while ((keyValueMatch = keyValueRegex.exec(appContent)) !== null) {
+                const key = keyValueMatch[1];
+                let value = keyValueMatch[2].trim();
+                // Handle quoted string values
+                if (value.startsWith('"') && value.endsWith('"')) {
+                    value = value.substring(1, value.length - 1);
+                }
+                if (key !== "GroupContainers" && key !== "SBAppTags") {
+                    appInfo[key] = value;
+                }
+            }
+            // parse GroupContainers
+            const groupContainersMatch = appContent.match(/GroupContainers\s+=\s+\{([^}]+)\};/);
+            if (groupContainersMatch) {
+                const groupContainersContent = groupContainersMatch[1];
+                const groupRegex = /"([^"]+)"\s+=\s+"([^"]+)"/g;
+                let groupMatch;
+                while ((groupMatch = groupRegex.exec(groupContainersContent)) !== null) {
+                    const groupId = groupMatch[1];
+                    const groupPath = groupMatch[2];
+                    appInfo.GroupContainers[groupId] = groupPath;
+                }
+            }
+            // parse SBAppTags
+            const sbAppTagsMatch = appContent.match(/SBAppTags\s+=\s+\(\s*(.*?)\s*\);/);
+            if (sbAppTagsMatch) {
+                const tagsContent = sbAppTagsMatch[1].trim();
+                if (tagsContent) {
+                    const tagRegex = /"([^"]+)"/g;
+                    let tagMatch;
+                    while ((tagMatch = tagRegex.exec(tagsContent)) !== null) {
+                        appInfo.SBAppTags.push(tagMatch[1]);
+                    }
+                }
+            }
+            result.push(appInfo);
+        }
+        return result;
+    }
+    async listApps() {
+        const text = this.simctl("listapps", this.simulatorUuid).toString();
+        const apps = this.parseIOSAppData(text);
+        return apps.map(app => app.CFBundleIdentifier);
+    }
+    async getScreenSize() {
+        return this.webDriverAgent.getScreenSize();
+    }
+    async sendKeys(keys) {
+        return this.webDriverAgent.sendKeys(keys);
+    }
+    async swipe(direction) {
+        await this.webDriverAgent.withinSession(async (sessionUrl) => {
+            const x0 = 200;
+            let y0 = 600;
+            const x1 = 200;
+            let y1 = 200;
+            if (direction === "up") {
+                const tmp = y0;
+                y0 = y1;
+                y1 = tmp;
+            }
+            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: x0, y: y0 },
+                                { type: "pointerDown", button: 0 },
+                                { type: "pointerMove", duration: 0, x: x1, y: y1 },
+                                { type: "pause", duration: 1000 },
+                                { type: "pointerUp", button: 0 }
+                            ]
+                        }
+                    ]
+                }),
+            });
+        });
+    }
+    async tap(x, y) {
+        await this.webDriverAgent.tap(x, y);
+    }
+    async pressButton(button) {
+        await this.webDriverAgent.pressButton(button);
+    }
+    async getElementsOnScreen() {
+        return await this.webDriverAgent.getElementsOnScreen();
+    }
+}
+exports.Simctl = Simctl;
+class SimctlManager {
+    parseSimulator(line) {
         // extract device name and UUID from the line
-        const match = line.match(/(.*?)\s+\(([\w-]+)\)\s+\(Booted\)/);
+        const match = line.match(/(.*?)\s+\(([\w-]+)\)\s+\((\w+)\)/);
         if (!match) {
             return null;
         }
         const deviceName = match[1].trim();
         const deviceUuid = match[2];
+        const deviceState = match[3];
         return {
             name: deviceName,
             uuid: deviceUuid,
+            state: deviceState,
         };
-    })
-        .filter(line => line !== null);
-};
-exports.getConnectedDevices = getConnectedDevices;
-const getScreenshot = (simulatorUuid) => {
-    return (0, child_process_1.execSync)(`xcrun simctl io "${simulatorUuid}" screenshot -`);
-};
-exports.getScreenshot = getScreenshot;
-const openUrl = (simulatorUuid, url) => {
-    return (0, child_process_1.execSync)(`xcrun simctl openurl "${simulatorUuid}" "${url}"`);
-};
-exports.openUrl = openUrl;
-const launchApp = (simulatorUuid, packageName) => {
-    return (0, child_process_1.execSync)(`xcrun simctl launch "${simulatorUuid}" "${packageName}"`);
-};
-exports.launchApp = launchApp;
-const listApps = (simulatorUuid) => {
-    return (0, child_process_1.execSync)(`xcrun simctl list apps "${simulatorUuid}"`);
-};
-exports.listApps = listApps;
+    }
+    listSimulators() {
+        return (0, child_process_1.execSync)(`xcrun simctl list devices`)
+            .toString()
+            .split("\n")
+            .map(line => this.parseSimulator(line))
+            .filter(simulator => simulator !== null);
+    }
+    listBootedSimulators() {
+        return this.listSimulators()
+            .filter(simulator => simulator.state === "Booted");
+    }
+    getSimulator(uuid) {
+        return new Simctl(uuid);
+    }
+}
+exports.SimctlManager = SimctlManager;

package/lib/robot.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/server.js

@@ -5,11 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMcpServer = void 0;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const child_process_1 = require("child_process");
-const logger_1 = require("./logger");
 const zod_1 = require("zod");
-const android_1 = require("./android");
 const sharp_1 = __importDefault(require("sharp"));
+const logger_1 = require("./logger");
+const android_1 = require("./android");
+const iphone_simulator_1 = require("./iphone-simulator");
+const ios_1 = require("./ios");
 const getAgentVersion = () => {
     const json = require("../package.json");
     return json.version;
@@ -43,68 +44,143 @@ const createMcpServer = () => {
         };
         server.tool(name, description, paramsSchema, args => wrappedCb(args));
     };
-    tool("list_apps_on_device", "List all apps on device", {}, async ({}) => {
-        const result = (0, android_1.listApps)();
+    let robot;
+    const simulatorManager = new iphone_simulator_1.SimctlManager();
+    tool("list_available_devices", "List all available devices. This includes both physical devices and simulators. If there is more than one device returned, you need to let the user select one of them.", {}, async ({}) => {
+        const iosManager = new ios_1.IosManager();
+        const devices = await simulatorManager.listBootedSimulators();
+        const simulatorNames = devices.map(d => d.name);
+        const androidDevices = (0, android_1.getConnectedDevices)();
+        const iosDevices = await iosManager.listDevices();
+        return `Found these iOS simulators: [${simulatorNames.join(".")}], iOS devices: [${iosDevices.join(",")}] and Android devices: [${androidDevices.join(",")}]`;
+    });
+    tool("use_device", "Select a device to use. This can be a simulator or an Android device. Use the list_available_devices tool to get a list of available devices.", {
+        device: zod_1.z.string().describe("The name of the device to select"),
+        deviceType: zod_1.z.enum(["simulator", "ios", "android"]).describe("The type of device to select"),
+    }, async ({ device, deviceType }) => {
+        console.log(device, deviceType);
+        switch (deviceType) {
+            case "simulator":
+                robot = simulatorManager.getSimulator(device);
+                break;
+            case "ios":
+                robot = new ios_1.IosRobot(device);
+                break;
+            case "android":
+                robot = new android_1.AndroidRobot(device);
+                break;
+        }
+        return `Selected device: ${device} (${deviceType})`;
+    });
+    tool("mobile_list_apps", "List all the installed apps on the device", {}, async ({}) => {
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        const result = await robot.listApps();
         return `Found these packages on device: ${result.join(",")}`;
     });
-    tool("launch_app", "Launch an app on mobile device", {
+    tool("mobile_launch_app", "Launch an app on mobile device. Use this to open a specific app. You can find the package name of the app by calling list_apps_on_device.", {
         packageName: zod_1.z.string().describe("The package name of the app to launch"),
     }, async ({ packageName }) => {
-        (0, child_process_1.execSync)(`adb shell monkey -p "${packageName}" -c android.intent.category.LAUNCHER 1`);
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        await robot.launchApp(packageName);
         return `Launched app ${packageName}`;
     });
-    tool("terminate_app", "Stop and terminate an app on mobile device", {
+    tool("mobile_terminate_app", "Stop and terminate an app on mobile device", {
         packageName: zod_1.z.string().describe("The package name of the app to terminate"),
     }, async ({ packageName }) => {
-        (0, child_process_1.execSync)(`adb shell am force-stop "${packageName}"`);
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        await robot.terminateApp(packageName);
         return `Terminated app ${packageName}`;
     });
-    tool("get_screen_size", "Get the screen size of the mobile device in pixels", {}, async ({}) => {
-        const screenSize = (0, android_1.getScreenSize)();
-        return `Screen size is ${screenSize[0]}x${screenSize[1]} pixels`;
+    tool("mobile_get_screen_size", "Get the screen size of the mobile device in pixels", {}, async ({}) => {
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        const screenSize = await robot.getScreenSize();
+        return `Screen size is ${screenSize.width}x${screenSize.height} pixels`;
     });
-    tool("click_on_screen_at_coordinates", "Click on the screen at given x,y coordinates", {
+    tool("mobile_click_on_screen_at_coordinates", "Click on the screen at given x,y coordinates", {
         x: zod_1.z.number().describe("The x coordinate to click between 0 and 1"),
         y: zod_1.z.number().describe("The y coordinate to click between 0 and 1"),
     }, async ({ x, y }) => {
-        const screenSize = (0, android_1.getScreenSize)();
-        const x0 = Math.floor(screenSize[0] * x);
-        const y0 = Math.floor(screenSize[1] * y);
-        (0, child_process_1.execSync)(`adb shell input tap ${x0} ${y0}`);
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        const screenSize = await robot.getScreenSize();
+        const x0 = Math.floor(screenSize.width * x);
+        const y0 = Math.floor(screenSize.height * y);
+        await robot.tap(x0, y0);
         return `Clicked on screen at coordinates: ${x}, ${y}`;
     });
-    tool("list_elements_on_screen", "List elements on screen and their coordinates, with display text or accessibility label. Do not cache this result.", {}, async ({}) => {
-        const elements = (0, android_1.getElementsOnScreen)();
-        return `Found these elements on screen: ${JSON.stringify(elements)}`;
+    tool("mobile_list_elements_on_screen", "List elements on screen and their coordinates, with display text or accessibility label. Do not cache this result.", {}, async ({}) => {
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        const screenSize = await robot.getScreenSize();
+        const elements = await robot.getElementsOnScreen();
+        const result = [];
+        for (let i = 0; i < elements.length; i++) {
+            elements[i].rect.x0 = elements[i].rect.x0 / screenSize.width;
+            elements[i].rect.y0 = elements[i].rect.y0 / screenSize.height;
+            elements[i].rect.x1 = elements[i].rect.x1 / screenSize.width;
+            elements[i].rect.y1 = elements[i].rect.y1 / screenSize.height;
+            result.push({
+                text: elements[i].label,
+                coordinates: {
+                    x: (elements[i].rect.x0 + elements[i].rect.x1) / 2,
+                    y: (elements[i].rect.y0 + elements[i].rect.y1) / 2,
+                }
+            });
+        }
+        return `Found these elements on screen: ${JSON.stringify(result)}`;
     });
-    tool("press_button", "Press a button on device", {
-        button: zod_1.z.string().describe("The button to press. Supported buttons: KEYCODE_BACK, KEYCODE_HOME, KEYCODE_MENU, KEYCODE_VOLUME_UP, KEYCODE_VOLUME_DOWN, KEYCODE_ENTER"),
+    tool("mobile_press_button", "Press a button on device", {
+        button: zod_1.z.string().describe("The button to press. Supported buttons: BACK, HOME, VOLUME_UP, VOLUME_DOWN, ENTER"),
     }, async ({ button }) => {
-        (0, child_process_1.execSync)(`adb shell input keyevent ${button}`);
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        robot.pressButton(button);
         return `Pressed the button: ${button}`;
     });
-    tool("open_url", "Open a URL in browser on device", {
+    tool("mobile_open_url", "Open a URL in browser on device", {
         url: zod_1.z.string().describe("The URL to open"),
     }, async ({ url }) => {
-        (0, child_process_1.execSync)(`adb shell am start -a android.intent.action.VIEW -d "${url}"`);
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        robot.openUrl(url);
         return `Opened URL: ${url}`;
     });
     tool("swipe_on_screen", "Swipe on the screen", {
         direction: zod_1.z.enum(["up", "down"]).describe("The direction to swipe"),
     }, async ({ direction }) => {
-        (0, android_1.swipe)(direction);
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        robot.swipe(direction);
         return `Swiped ${direction} on screen`;
     });
-    tool("type_text", "Type text into the focused element", {
+    tool("mobile_type_keys", "Type text into the focused element", {
         text: zod_1.z.string().describe("The text to type"),
     }, async ({ text }) => {
-        const _text = text.replace(/ /g, "\\ ");
-        (0, child_process_1.execSync)(`adb shell input text "${_text}"`);
+        if (!robot) {
+            throw new Error("No device selected");
+        }
+        robot.sendKeys(text);
         return `Typed text: ${text}`;
     });
-    server.tool("take_device_screenshot", "Take a screenshot of the mobile device. Use this to understand what's on screen, if you need to press an element that is available through view hierarchy then you must list elements on screen instead. Do not cache this result.", {}, async ({}) => {
+    server.tool("mobile_take_screenshot", "Take a screenshot of the mobile device. Use this to understand what's on screen, if you need to press an element that is available through view hierarchy then you must list elements on screen instead. Do not cache this result.", {}, async ({}) => {
+        if (!robot) {
+            throw new Error("No device selected");
+        }
         try {
-            const screenshot = await (0, android_1.takeScreenshot)();
+            const screenshot = await robot.getScreenshot();
             // Scale down the screenshot by 50%
             const image = (0, sharp_1.default)(screenshot);
             const metadata = await image.metadata();

package/lib/webdriver-agent.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDriverAgent = void 0;
+class WebDriverAgent {
+    host;
+    port;
+    constructor(host, port) {
+        this.host = host;
+        this.port = port;
+    }
+    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" } } }),
+        });
+        const json = await response.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() {
+        return this.withinSession(async (sessionUrl) => {
+            const url = `${sessionUrl}/wda/screen`;
+            const response = await fetch(url);
+            const json = await response.json();
+            return {
+                width: json.value.screenSize.width * json.value.scale,
+                height: json.value.screenSize.height * json.value.scale,
+            };
+        });
+    }
+    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 Error(`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 }
+                            ]
+                        }
+                    ]
+                }),
+            });
+        });
+    }
+    filterSourceElements(source) {
+        const output = [];
+        if (["TextField", "Button", "Switch"].includes(source.type)) {
+            output.push({
+                type: source.type,
+                label: source.label,
+                name: source.name,
+                rect: {
+                    x0: source.rect.x,
+                    y0: source.rect.y,
+                    x1: source.rect.x + source.rect.width,
+                    y1: source.rect.y + 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);
+    }
+}
+exports.WebDriverAgent = WebDriverAgent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mobilenext/mobile-mcp",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Mobile MCP",
   "repository": {
     "type": "git",
@@ -13,16 +13,14 @@
   "scripts": {
     "build": "tsc && chmod +x lib/index.js",
     "lint": "eslint .",
+    "test": "mocha --require ts-node/register test/*.ts",
     "watch": "tsc --watch",
-    "clean": "rm -rf lib"
-  },
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./index.js"
-    }
+    "clean": "rm -rf lib",
+    "prepare": "husky"
   },
+  "files": [
+    "lib"
+  ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.1",
     "fast-xml-parser": "^5.0.9",
@@ -33,6 +31,7 @@
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.19.0",
     "@stylistic/eslint-plugin": "^3.0.1",
+    "@types/mocha": "^10.0.10",
     "@types/node": "^22.13.10",
     "@typescript-eslint/eslint-plugin": "^8.28.0",
     "@typescript-eslint/parser": "^8.26.1",
@@ -41,6 +40,9 @@
     "eslint-plugin": "^1.0.1",
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-notice": "^1.0.0",
+    "husky": "^9.1.7",
+    "mocha": "^11.1.0",
+    "ts-node": "^10.9.2",
     "typescript": "^5.8.2"
   },
   "main": "index.js",