@mobilenext/mobile-mcp 0.0.37 → 0.0.39

package/README.md

@@ -137,6 +137,32 @@ More details in our [wiki page](https://github.com/mobile-next/mobile-mcp/wiki)
 }
 ```
 
+<details>
+<summary>Amp</summary>
+
+Add via the Amp VS Code extension settings screen or by updating your `settings.json` file:
+
+```json
+"amp.mcpServers": {
+  "mobile-mcp": {
+    "command": "npx",
+    "args": [
+      "@mobilenext/mobile-mcp@latest"
+    ]
+  }
+}
+```
+
+**Amp CLI:**
+
+Run the following command in your terminal:
+
+```bash
+amp mcp add mobile-mcp -- npx @mobilenext/mobile-mcp@latest
+```
+
+</details>
+
 <details>
 <summary>Cline</summary>
 
@@ -154,6 +180,65 @@ Use the Claude Code CLI to add the Mobile MCP server:
 ```bash
 claude mcp add mobile-mcp -- npx -y @mobilenext/mobile-mcp@latest
 ```
+</details>
+
+<details>
+<summary>Claude Desktop</summary>
+
+Follow the [MCP install guide](https://modelcontextprotocol.io/quickstart/user), use json configuration above.
+
+</details>
+
+<details>
+<summary>Codex</summary>
+
+Use the Codex CLI to add the Mobile MCP server:
+
+```bash
+codex mcp add mobile-mcp npx "@mobilenext/mobile-mcp@latest"
+```
+
+Alternatively, create or edit the configuration file `~/.codex/config.toml` and add:
+
+```toml
+[mcp_servers.mobile-mcp]
+command = "npx"
+args = ["@mobilenext/mobile-mcp@latest"]
+```
+
+For more information, see the Codex MCP documentation.
+
+</details>
+
+<details>
+<summary>Copilot</summary>
+
+Use the Copilot CLI to interactively add the Mobile MCP server:
+
+```text
+/mcp add
+```
+
+You can edit the configuration file `~/.copilot/mcp-config.json` and add:
+
+```json
+{
+  "mcpServers": {
+    "mobile-mcp": {
+      "type": "local",
+      "command": "npx",
+      "tools": [
+        "*"
+      ],
+      "args": [
+        "@mobilenext/mobile-mcp@latest"
+      ]
+    }
+  }
+}
+```
+
+For more information, see the Copilot CLI documentation.
 
 </details>
 
@@ -194,6 +279,49 @@ Go to `Advanced settings` -> `Extensions` -> `Add custom extension`. Name to you
 
 </details>
 
+<details>
+<summary>Kiro</summary>
+
+Follow the MCP Servers [documentation](https://kiro.dev/docs/mcp/). For example in `.kiro/settings/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "mobile-mcp": {
+      "command": "npx",
+      "args": [
+        "@mobilenext/mobile-mcp@latest"
+      ]
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary>opencode</summary>
+
+Follow the MCP Servers documentation. For example in `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "mobile-mcp": {
+      "type": "local",
+      "command": [
+        "npx",
+        "@mobilenext/mobile-mcp@latest"
+      ],
+      "enabled": true
+    }
+  }
+}
+```
+
+</details>
+
 <details>
 <summary>Qodo Gen</summary>
 
@@ -203,6 +331,21 @@ Click <code>Save</code>.
 
 </details>
 
+
+<details>
+<summary>Windsurf</summary>
+
+Open Windsurf settings, navigate to MCP servers, and add a new server using the `command` type with:
+
+```bash
+npx @mobilenext/mobile-mcp@latest
+```
+
+Or add the standard config under `mcpServers` in your settings as shown above.
+
+</details>
+
+
 [Read more in our wiki](https://github.com/mobile-next/mobile-mcp/wiki)! 🚀
 
 
@@ -309,4 +452,3 @@ On iOS, you'll need Xcode and to run the Simulator before using Mobile MCP with
   <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

@@ -399,9 +399,9 @@ class AndroidRobot {
     async tap(x, y) {
         this.adb("shell", "input", "tap", `${x}`, `${y}`);
     }
-    async longPress(x, y) {
+    async longPress(x, y, duration) {
         // a long press is a swipe with no movement and a long duration
-        this.adb("shell", "input", "swipe", `${x}`, `${y}`, `${x}`, `${y}`, "500");
+        this.adb("shell", "input", "swipe", `${x}`, `${y}`, `${x}`, `${y}`, `${duration}`);
     }
     async doubleTap(x, y) {
         await this.tap(x, y);
@@ -461,6 +461,37 @@ class AndroidDeviceManager {
         }
         return "mobile";
     }
+    getDeviceVersion(deviceId) {
+        try {
+            const output = (0, node_child_process_1.execFileSync)(getAdbPath(), ["-s", deviceId, "shell", "getprop", "ro.build.version.release"], {
+                timeout: 5000,
+            }).toString().trim();
+            return output;
+        }
+        catch (error) {
+            return "unknown";
+        }
+    }
+    getDeviceName(deviceId) {
+        try {
+            // Try getting AVD name first (for emulators)
+            const avdName = (0, node_child_process_1.execFileSync)(getAdbPath(), ["-s", deviceId, "shell", "getprop", "ro.boot.qemu.avd_name"], {
+                timeout: 5000,
+            }).toString().trim();
+            if (avdName !== "") {
+                // Replace underscores with spaces (e.g., "Pixel_9_Pro" -> "Pixel 9 Pro")
+                return avdName.replace(/_/g, " ");
+            }
+            // Fall back to product model
+            const output = (0, node_child_process_1.execFileSync)(getAdbPath(), ["-s", deviceId, "shell", "getprop", "ro.product.model"], {
+                timeout: 5000,
+            }).toString().trim();
+            return output;
+        }
+        catch (error) {
+            return deviceId;
+        }
+    }
     getConnectedDevices() {
         try {
             const names = (0, node_child_process_1.execFileSync)(getAdbPath(), ["devices"])
@@ -480,5 +511,26 @@ class AndroidDeviceManager {
             return [];
         }
     }
+    getConnectedDevicesWithDetails() {
+        try {
+            const names = (0, node_child_process_1.execFileSync)(getAdbPath(), ["devices"])
+                .toString()
+                .split("\n")
+                .map(line => line.trim())
+                .filter(line => line !== "")
+                .filter(line => !line.startsWith("List of devices attached"))
+                .map(line => line.split("\t")[0]);
+            return names.map(deviceId => ({
+                deviceId,
+                deviceType: this.getDeviceType(deviceId),
+                version: this.getDeviceVersion(deviceId),
+                name: this.getDeviceName(deviceId),
+            }));
+        }
+        catch (error) {
+            console.error("Could not execute adb command, maybe ANDROID_HOME is not set?");
+            return [];
+        }
+    }
 }
 exports.AndroidDeviceManager = AndroidDeviceManager;

package/lib/ios.js

@@ -145,9 +145,9 @@ class IosRobot {
         const wda = await this.wda();
         await wda.doubleTap(x, y);
     }
-    async longPress(x, y) {
+    async longPress(x, y, duration) {
         const wda = await this.wda();
-        await wda.longPress(x, y);
+        await wda.longPress(x, y, duration);
     }
     async getElementsOnScreen() {
         const wda = await this.wda();
@@ -191,6 +191,11 @@ class IosManager {
         const json = JSON.parse(output);
         return json.DeviceName;
     }
+    getDeviceInfo(deviceId) {
+        const output = (0, node_child_process_1.execFileSync)(getGoIosPath(), ["info", "--udid", deviceId]).toString();
+        const json = JSON.parse(output);
+        return json;
+    }
     listDevices() {
         if (!this.isGoIosInstalled()) {
             console.error("go-ios is not installed, no physical iOS devices can be detected");
@@ -204,5 +209,22 @@ class IosManager {
         }));
         return devices;
     }
+    listDevicesWithDetails() {
+        if (!this.isGoIosInstalled()) {
+            console.error("go-ios is not installed, no physical iOS devices can be detected");
+            return [];
+        }
+        const output = (0, node_child_process_1.execFileSync)(getGoIosPath(), ["list"]).toString();
+        const json = JSON.parse(output);
+        const devices = json.deviceList.map(device => {
+            const info = this.getDeviceInfo(device);
+            return {
+                deviceId: device,
+                deviceName: info.DeviceName,
+                version: info.ProductVersion,
+            };
+        });
+        return devices;
+    }
 }
 exports.IosManager = IosManager;

package/lib/iphone-simulator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimctlManager = exports.Simctl = void 0;
+exports.Simctl = void 0;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
@@ -192,9 +192,9 @@ class Simctl {
         const wda = await this.wda();
         await wda.doubleTap(x, y);
     }
-    async longPress(x, y) {
+    async longPress(x, y, duration) {
         const wda = await this.wda();
-        return wda.longPress(x, y);
+        return wda.longPress(x, y, duration);
     }
     async pressButton(button) {
         const wda = await this.wda();
@@ -214,37 +214,3 @@ class Simctl {
     }
 }
 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, node_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/mobile-device.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileDevice = void 0;
+const mobilecli_1 = require("./mobilecli");
+class MobileDevice {
+    deviceId;
+    mobilecli;
+    constructor(deviceId) {
+        this.deviceId = deviceId;
+        this.mobilecli = new mobilecli_1.Mobilecli();
+    }
+    runCommand(args) {
+        const fullArgs = [...args, "--device", this.deviceId];
+        return this.mobilecli.executeCommand(fullArgs);
+    }
+    async getScreenSize() {
+        const response = JSON.parse(this.runCommand(["device", "info"]));
+        if (response.data.device.screenSize) {
+            return response.data.device.screenSize;
+        }
+        return { width: 0, height: 0, scale: 1.0 };
+    }
+    async swipe(direction) {
+        const screenSize = await this.getScreenSize();
+        const centerX = Math.floor(screenSize.width / 2);
+        const centerY = Math.floor(screenSize.height / 2);
+        const distance = 400; // Default distance in pixels
+        let startX = centerX;
+        let startY = centerY;
+        let endX = centerX;
+        let endY = centerY;
+        switch (direction) {
+            case "up":
+                startY = centerY + distance / 2;
+                endY = centerY - distance / 2;
+                break;
+            case "down":
+                startY = centerY - distance / 2;
+                endY = centerY + distance / 2;
+                break;
+            case "left":
+                startX = centerX + distance / 2;
+                endX = centerX - distance / 2;
+                break;
+            case "right":
+                startX = centerX - distance / 2;
+                endX = centerX + distance / 2;
+                break;
+        }
+        this.runCommand(["io", "swipe", `${startX},${startY},${endX},${endY}`]);
+    }
+    async swipeFromCoordinate(x, y, direction, distance) {
+        const swipeDistance = distance || 400;
+        let endX = x;
+        let endY = y;
+        switch (direction) {
+            case "up":
+                endY = y - swipeDistance;
+                break;
+            case "down":
+                endY = y + swipeDistance;
+                break;
+            case "left":
+                endX = x - swipeDistance;
+                break;
+            case "right":
+                endX = x + swipeDistance;
+                break;
+        }
+        this.runCommand(["io", "swipe", `${x},${y},${endX},${endY}`]);
+    }
+    async getScreenshot() {
+        const fullArgs = ["screenshot", "--device", this.deviceId, "--format", "png", "--output", "-"];
+        return this.mobilecli.executeCommandBuffer(fullArgs);
+    }
+    async listApps() {
+        const response = JSON.parse(this.runCommand(["apps", "list"]));
+        return response.data.map(app => ({
+            appName: app.appName || app.packageName,
+            packageName: app.packageName,
+        }));
+    }
+    async launchApp(packageName) {
+        this.runCommand(["apps", "launch", packageName]);
+    }
+    async terminateApp(packageName) {
+        this.runCommand(["apps", "terminate", packageName]);
+    }
+    async installApp(path) {
+        this.runCommand(["apps", "install", path]);
+    }
+    async uninstallApp(bundleId) {
+        this.runCommand(["apps", "uninstall", bundleId]);
+    }
+    async openUrl(url) {
+        this.runCommand(["url", url]);
+    }
+    async sendKeys(text) {
+        this.runCommand(["io", "text", text]);
+    }
+    async pressButton(button) {
+        this.runCommand(["io", "button", button]);
+    }
+    async tap(x, y) {
+        this.runCommand(["io", "tap", `${x},${y}`]);
+    }
+    async doubleTap(x, y) {
+        // TODO: should move into mobilecli itself as "io doubletap"
+        await this.tap(x, y);
+        await this.tap(x, y);
+    }
+    async longPress(x, y, duration) {
+        this.runCommand(["io", "longpress", `${x},${y}`, "--duration", `${duration}`]);
+    }
+    async getElementsOnScreen() {
+        const response = JSON.parse(this.runCommand(["dump", "ui"]));
+        return response.data.elements.map(element => ({
+            type: element.type,
+            label: element.label,
+            text: element.text,
+            name: element.name,
+            value: element.value,
+            identifier: element.identifier,
+            rect: element.rect,
+            focused: element.focused,
+        }));
+    }
+    async setOrientation(orientation) {
+        this.runCommand(["device", "orientation", "set", orientation]);
+    }
+    async getOrientation() {
+        const response = JSON.parse(this.runCommand(["device", "orientation", "get"]));
+        return response.data.orientation;
+    }
+}
+exports.MobileDevice = MobileDevice;

package/lib/mobilecli.js

@@ -1,58 +1,97 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMobilecliPath = void 0;
+exports.Mobilecli = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const getMobilecliPath = () => {
-    if (process.env.MOBILECLI_PATH) {
-        return process.env.MOBILECLI_PATH;
+const node_child_process_1 = require("node:child_process");
+const TIMEOUT = 30000;
+const MAX_BUFFER_SIZE = 1024 * 1024 * 4;
+class Mobilecli {
+    path = null;
+    constructor() { }
+    getPath() {
+        if (!this.path) {
+            this.path = Mobilecli.getMobilecliPath();
+        }
+        return this.path;
     }
-    const arch = process.arch;
-    const platform = process.platform;
-    let binaryName = "mobilecli";
-    switch (platform) {
-        case "darwin":
-            if (arch === "arm64") {
-                binaryName += "-darwin-arm64";
-            }
-            else {
-                binaryName += "-darwin-amd64";
-            }
-            break;
-        case "linux":
-            if (arch === "arm64") {
-                binaryName += "-linux-arm64";
-            }
-            else {
-                binaryName += "-linux-amd64";
-            }
-            break;
-        case "win32":
-            binaryName += "-windows-amd64.exe";
-            break;
-        default:
-            throw new Error(`Unsupported platform: ${platform}`);
+    executeCommand(args) {
+        const path = this.getPath();
+        return (0, node_child_process_1.execFileSync)(path, args, { encoding: "utf8" }).toString().trim();
     }
-    // Check if mobile-mcp is installed as a package
-    const currentPath = __filename;
-    const pathParts = currentPath.split(node_path_1.sep);
-    const lastNodeModulesIndex = pathParts.lastIndexOf("node_modules");
-    if (lastNodeModulesIndex !== -1) {
-        // We're inside node_modules, go to the last node_modules in the path
-        const nodeModulesParts = pathParts.slice(0, lastNodeModulesIndex + 1);
-        const lastNodeModulesPath = nodeModulesParts.join(node_path_1.sep);
-        const mobilecliPath = (0, node_path_1.join)(lastNodeModulesPath, "@mobilenext", "mobilecli", "bin", binaryName);
+    executeCommandBuffer(args) {
+        const path = this.getPath();
+        return (0, node_child_process_1.execFileSync)(path, args, {
+            encoding: "buffer",
+            maxBuffer: MAX_BUFFER_SIZE,
+            timeout: TIMEOUT,
+        });
+    }
+    static getMobilecliPath() {
+        if (process.env.MOBILECLI_PATH) {
+            return process.env.MOBILECLI_PATH;
+        }
+        const platform = process.platform;
+        const arch = process.arch;
+        const normalizedPlatform = platform === "win32" ? "windows" : platform;
+        const normalizedArch = arch === "arm64" ? "arm64" : "amd64";
+        const ext = platform === "win32" ? ".exe" : "";
+        const binaryName = `mobilecli-${normalizedPlatform}-${normalizedArch}${ext}`;
+        // Check if mobile-mcp is installed as a package
+        const currentPath = __filename;
+        const pathParts = currentPath.split(node_path_1.sep);
+        const lastNodeModulesIndex = pathParts.lastIndexOf("node_modules");
+        if (lastNodeModulesIndex !== -1) {
+            // We're inside node_modules, go to the last node_modules in the path
+            const nodeModulesParts = pathParts.slice(0, lastNodeModulesIndex + 1);
+            const lastNodeModulesPath = nodeModulesParts.join(node_path_1.sep);
+            const mobilecliPath = (0, node_path_1.join)(lastNodeModulesPath, "@mobilenext", "mobilecli", "bin", binaryName);
+            if ((0, node_fs_1.existsSync)(mobilecliPath)) {
+                return mobilecliPath;
+            }
+        }
+        // Not in node_modules, look one directory up from current script
+        const scriptDir = (0, node_path_1.dirname)(__filename);
+        const parentDir = (0, node_path_1.dirname)(scriptDir);
+        const mobilecliPath = (0, node_path_1.join)(parentDir, "node_modules", "@mobilenext", "mobilecli", "bin", binaryName);
         if ((0, node_fs_1.existsSync)(mobilecliPath)) {
             return mobilecliPath;
         }
+        throw new Error(`Could not find mobilecli binary for platform: ${platform}`);
     }
-    // Not in node_modules, look one directory up from current script
-    const scriptDir = (0, node_path_1.dirname)(__filename);
-    const parentDir = (0, node_path_1.dirname)(scriptDir);
-    const mobilecliPath = (0, node_path_1.join)(parentDir, "node_modules", "@mobilenext", "mobilecli", "bin", binaryName);
-    if ((0, node_fs_1.existsSync)(mobilecliPath)) {
-        return mobilecliPath;
+    getVersion() {
+        try {
+            const output = this.executeCommand(["--version"]);
+            if (output.startsWith("mobilecli version ")) {
+                return output.substring("mobilecli version ".length);
+            }
+            return "failed";
+        }
+        catch (error) {
+            return "failed " + error.message;
+        }
+    }
+    getDevices(options) {
+        const args = ["devices"];
+        if (options) {
+            if (options.includeOffline) {
+                args.push("--include-offline");
+            }
+            if (options.platform) {
+                if (options.platform !== "ios" && options.platform !== "android") {
+                    throw new Error(`Invalid platform: ${options.platform}. Must be "ios" or "android"`);
+                }
+                args.push("--platform", options.platform);
+            }
+            if (options.type) {
+                if (options.type !== "real" && options.type !== "emulator" && options.type !== "simulator") {
+                    throw new Error(`Invalid type: ${options.type}. Must be "real", "emulator", or "simulator"`);
+                }
+                args.push("--type", options.type);
+            }
+        }
+        const mobilecliOutput = this.executeCommand(args);
+        return JSON.parse(mobilecliOutput);
     }
-    throw new Error(`Could not find mobilecli binary for platform: ${platform}`);
-};
-exports.getMobilecliPath = getMobilecliPath;
+}
+exports.Mobilecli = Mobilecli;

package/lib/server.js

@@ -9,15 +9,14 @@ const zod_1 = require("zod");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_crypto_1 = __importDefault(require("node:crypto"));
-const node_child_process_1 = require("node:child_process");
 const logger_1 = require("./logger");
 const android_1 = require("./android");
 const robot_1 = require("./robot");
-const iphone_simulator_1 = require("./iphone-simulator");
 const ios_1 = require("./ios");
 const png_1 = require("./png");
 const image_utils_1 = require("./image-utils");
 const mobilecli_1 = require("./mobilecli");
+const mobile_device_1 = require("./mobile-device");
 const getAgentVersion = () => {
     const json = require("../package.json");
     return json.version;
@@ -40,17 +39,20 @@ const createMcpServer = () => {
             return "unknown";
         }
     };
-    const tool = (name, title, description, paramsSchema, cb) => {
+    const tool = (name, title, description, paramsSchema, annotations, cb) => {
         server.registerTool(name, {
             title,
             description,
             inputSchema: paramsSchema,
+            annotations,
         }, (async (args, _extra) => {
             try {
                 (0, logger_1.trace)(`Invoking ${name} with args: ${JSON.stringify(args)}`);
+                const start = +new Date();
                 const response = await cb(args);
+                const duration = +new Date() - start;
                 (0, logger_1.trace)(`=> ${response}`);
-                posthog("tool_invoked", { "ToolName": name }).then();
+                posthog("tool_invoked", { "ToolName": name, "Duration": duration }).then();
                 return {
                     content: [{ type: "text", text: response }],
                 };
@@ -109,109 +111,112 @@ const createMcpServer = () => {
             // ignore
         }
     };
-    const getMobilecliVersion = () => {
+    const mobilecli = new mobilecli_1.Mobilecli();
+    posthog("launch", {}).then();
+    const ensureMobilecliAvailable = () => {
         try {
-            const path = (0, mobilecli_1.getMobilecliPath)();
-            const output = (0, node_child_process_1.execFileSync)(path, ["--version"], { encoding: "utf8" }).toString().trim();
-            if (output.startsWith("mobilecli version ")) {
-                return output.substring("mobilecli version ".length);
+            const version = mobilecli.getVersion();
+            if (version.startsWith("failed")) {
+                throw new Error("mobilecli version check failed");
             }
-            return "failed";
         }
         catch (error) {
-            return "failed " + error.message;
+            throw new robot_1.ActionableError(`mobilecli is not available or not working properly. Please review the documentation at https://github.com/mobile-next/mobile-mcp/wiki for installation instructions`);
         }
     };
-    const getMobilecliDevices = () => {
-        const mobilecliPath = (0, mobilecli_1.getMobilecliPath)();
-        const mobilecliOutput = (0, node_child_process_1.execFileSync)(mobilecliPath, ["devices"], { encoding: "utf8" }).toString().trim();
-        return JSON.parse(mobilecliOutput);
-    };
-    const mobilecliVersion = getMobilecliVersion();
-    posthog("launch", { "MobilecliVersion": mobilecliVersion }).then();
-    const simulatorManager = new iphone_simulator_1.SimctlManager();
-    const getRobotFromDevice = (device) => {
+    const getRobotFromDevice = (deviceId) => {
+        // from now on, we must have mobilecli working
+        ensureMobilecliAvailable();
+        // Check if it's an iOS device
         const iosManager = new ios_1.IosManager();
-        const androidManager = new android_1.AndroidDeviceManager();
-        const simulators = simulatorManager.listBootedSimulators();
-        const androidDevices = androidManager.getConnectedDevices();
         const iosDevices = iosManager.listDevices();
-        // Check if it's a simulator
-        const simulator = simulators.find(s => s.name === device);
-        if (simulator) {
-            return simulatorManager.getSimulator(device);
+        const iosDevice = iosDevices.find(d => d.deviceId === deviceId);
+        if (iosDevice) {
+            return new ios_1.IosRobot(deviceId);
         }
         // Check if it's an Android device
-        const androidDevice = androidDevices.find(d => d.deviceId === device);
+        const androidManager = new android_1.AndroidDeviceManager();
+        const androidDevices = androidManager.getConnectedDevices();
+        const androidDevice = androidDevices.find(d => d.deviceId === deviceId);
         if (androidDevice) {
-            return new android_1.AndroidRobot(device);
+            return new android_1.AndroidRobot(deviceId);
         }
-        // Check if it's an iOS device
-        const iosDevice = iosDevices.find(d => d.deviceId === device);
-        if (iosDevice) {
-            return new ios_1.IosRobot(device);
+        // Check if it's a simulator (will later replace all other device types as well)
+        const response = mobilecli.getDevices({
+            platform: "ios",
+            type: "simulator",
+            includeOffline: false,
+        });
+        if (response.status === "ok" && response.data && response.data.devices) {
+            for (const device of response.data.devices) {
+                if (device.id === deviceId) {
+                    return new mobile_device_1.MobileDevice(deviceId);
+                }
+            }
         }
-        throw new robot_1.ActionableError(`Device "${device}" not found. Use the mobile_list_available_devices tool to see available devices.`);
+        throw new robot_1.ActionableError(`Device "${deviceId}" not found. Use the mobile_list_available_devices tool to see available devices.`);
     };
     tool("mobile_list_available_devices", "List 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.", {
         noParams
-    }, async ({}) => {
+    }, { readOnlyHint: true }, async ({}) => {
+        // from today onward, we must have mobilecli working
+        ensureMobilecliAvailable();
         const iosManager = new ios_1.IosManager();
         const androidManager = new android_1.AndroidDeviceManager();
-        const simulators = simulatorManager.listBootedSimulators();
-        const simulatorNames = simulators.map(d => d.name);
-        const androidDevices = androidManager.getConnectedDevices();
-        const iosDevices = await iosManager.listDevices();
-        const iosDeviceNames = iosDevices.map(d => d.deviceId);
-        const androidTvDevices = androidDevices.filter(d => d.deviceType === "tv").map(d => d.deviceId);
-        const androidMobileDevices = androidDevices.filter(d => d.deviceType === "mobile").map(d => d.deviceId);
-        if (true) {
-            // gilm: this is new code to verify first that mobilecli detects more or equal number of devices.
-            // in an attempt to make the smoothest transition from go-ios+xcrun+adb+iproxy+sips+imagemagick+wda to
-            // a single cli tool.
-            const deviceCount = simulators.length + iosDevices.length + androidDevices.length;
-            let mobilecliDeviceCount = 0;
-            try {
-                const response = getMobilecliDevices();
-                if (response.status === "ok" && response.data && response.data.devices) {
-                    mobilecliDeviceCount = response.data.devices.length;
-                }
-            }
-            catch (error) {
-                // if mobilecli fails, we'll just set count to 0
-            }
-            if (deviceCount === mobilecliDeviceCount) {
-                posthog("debug_mobilecli_same_number_of_devices", {
-                    "DeviceCount": deviceCount,
-                    "MobilecliDeviceCount": mobilecliDeviceCount,
-                }).then();
-            }
-            else {
-                posthog("debug_mobilecli_different_number_of_devices", {
-                    "DeviceCount": deviceCount,
-                    "MobilecliDeviceCount": mobilecliDeviceCount,
-                    "DeviceCountDifference": deviceCount - mobilecliDeviceCount,
-                }).then();
-            }
-        }
-        const resp = ["Found these devices:"];
-        if (simulatorNames.length > 0) {
-            resp.push(`iOS simulators: [${simulatorNames.join(",")}]`);
+        const devices = [];
+        // Get Android devices with details
+        const androidDevices = androidManager.getConnectedDevicesWithDetails();
+        for (const device of androidDevices) {
+            devices.push({
+                id: device.deviceId,
+                name: device.name,
+                platform: "android",
+                type: "emulator",
+                version: device.version,
+                state: "online",
+            });
         }
-        if (iosDevices.length > 0) {
-            resp.push(`iOS devices: [${iosDeviceNames.join(",")}]`);
+        // Get iOS physical devices with details
+        try {
+            const iosDevices = iosManager.listDevicesWithDetails();
+            for (const device of iosDevices) {
+                devices.push({
+                    id: device.deviceId,
+                    name: device.deviceName,
+                    platform: "ios",
+                    type: "real",
+                    version: device.version,
+                    state: "online",
+                });
+            }
         }
-        if (androidMobileDevices.length > 0) {
-            resp.push(`Android devices: [${androidMobileDevices.join(",")}]`);
+        catch (error) {
+            // If go-ios is not available, silently skip
         }
-        if (androidTvDevices.length > 0) {
-            resp.push(`Android TV devices: [${androidTvDevices.join(",")}]`);
+        // Get iOS simulators from mobilecli (excluding offline devices)
+        const response = mobilecli.getDevices({
+            platform: "ios",
+            type: "simulator",
+            includeOffline: false,
+        });
+        if (response.status === "ok" && response.data && response.data.devices) {
+            for (const device of response.data.devices) {
+                devices.push({
+                    id: device.id,
+                    name: device.name,
+                    platform: device.platform,
+                    type: device.type,
+                    version: device.version,
+                    state: "online",
+                });
+            }
         }
-        return resp.join("\n");
+        const out = { devices };
+        return JSON.stringify(out);
     });
     tool("mobile_list_apps", "List Apps", "List all the installed apps on the device", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
-    }, async ({ device }) => {
+    }, { readOnlyHint: true }, async ({ device }) => {
         const robot = getRobotFromDevice(device);
         const result = await robot.listApps();
         return `Found these apps on device: ${result.map(app => `${app.appName} (${app.packageName})`).join(", ")}`;
@@ -219,7 +224,7 @@ const createMcpServer = () => {
     tool("mobile_launch_app", "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.", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         packageName: zod_1.z.string().describe("The package name of the app to launch"),
-    }, async ({ device, packageName }) => {
+    }, { destructiveHint: true }, async ({ device, packageName }) => {
         const robot = getRobotFromDevice(device);
         await robot.launchApp(packageName);
         return `Launched app ${packageName}`;
@@ -227,7 +232,7 @@ const createMcpServer = () => {
     tool("mobile_terminate_app", "Terminate App", "Stop and terminate an app on mobile device", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         packageName: zod_1.z.string().describe("The package name of the app to terminate"),
-    }, async ({ device, packageName }) => {
+    }, { destructiveHint: true }, async ({ device, packageName }) => {
         const robot = getRobotFromDevice(device);
         await robot.terminateApp(packageName);
         return `Terminated app ${packageName}`;
@@ -235,7 +240,7 @@ const createMcpServer = () => {
     tool("mobile_install_app", "Install App", "Install an app on mobile device", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         path: zod_1.z.string().describe("The path to the app file to install. For iOS simulators, provide a .zip file or a .app directory. For Android provide an .apk file. For iOS real devices provide an .ipa file"),
-    }, async ({ device, path }) => {
+    }, { destructiveHint: true }, async ({ device, path }) => {
         const robot = getRobotFromDevice(device);
         await robot.installApp(path);
         return `Installed app from ${path}`;
@@ -243,14 +248,14 @@ const createMcpServer = () => {
     tool("mobile_uninstall_app", "Uninstall App", "Uninstall an app from mobile device", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         bundle_id: zod_1.z.string().describe("Bundle identifier (iOS) or package name (Android) of the app to be uninstalled"),
-    }, async ({ device, bundle_id }) => {
+    }, { destructiveHint: true }, async ({ device, bundle_id }) => {
         const robot = getRobotFromDevice(device);
         await robot.uninstallApp(bundle_id);
         return `Uninstalled app ${bundle_id}`;
     });
     tool("mobile_get_screen_size", "Get Screen Size", "Get the screen size of the mobile device in pixels", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
-    }, async ({ device }) => {
+    }, { readOnlyHint: true }, async ({ device }) => {
         const robot = getRobotFromDevice(device);
         const screenSize = await robot.getScreenSize();
         return `Screen size is ${screenSize.width}x${screenSize.height} pixels`;
@@ -259,7 +264,7 @@ const createMcpServer = () => {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         x: zod_1.z.number().describe("The x coordinate to click on the screen, in pixels"),
         y: zod_1.z.number().describe("The y coordinate to click on the screen, in pixels"),
-    }, async ({ device, x, y }) => {
+    }, { destructiveHint: true }, async ({ device, x, y }) => {
         const robot = getRobotFromDevice(device);
         await robot.tap(x, y);
         return `Clicked on screen at coordinates: ${x}, ${y}`;
@@ -268,7 +273,7 @@ const createMcpServer = () => {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         x: zod_1.z.number().describe("The x coordinate to double-tap, in pixels"),
         y: zod_1.z.number().describe("The y coordinate to double-tap, in pixels"),
-    }, async ({ device, x, y }) => {
+    }, { destructiveHint: true }, async ({ device, x, y }) => {
         const robot = getRobotFromDevice(device);
         await robot.doubleTap(x, y);
         return `Double-tapped on screen at coordinates: ${x}, ${y}`;
@@ -277,14 +282,16 @@ const createMcpServer = () => {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         x: zod_1.z.number().describe("The x coordinate to long press on the screen, in pixels"),
         y: zod_1.z.number().describe("The y coordinate to long press on the screen, in pixels"),
-    }, async ({ device, x, y }) => {
+        duration: zod_1.z.number().min(1).max(10000).optional().describe("Duration of the long press in milliseconds. Defaults to 500ms."),
+    }, { destructiveHint: true }, async ({ device, x, y, duration }) => {
         const robot = getRobotFromDevice(device);
-        await robot.longPress(x, y);
-        return `Long pressed on screen at coordinates: ${x}, ${y}`;
+        const pressDuration = duration ?? 500;
+        await robot.longPress(x, y, pressDuration);
+        return `Long pressed on screen at coordinates: ${x}, ${y} for ${pressDuration}ms`;
     });
     tool("mobile_list_elements_on_screen", "List Screen Elements", "List elements on screen and their coordinates, with display text or accessibility label. Do not cache this result.", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
-    }, async ({ device }) => {
+    }, { readOnlyHint: true }, async ({ device }) => {
         const robot = getRobotFromDevice(device);
         const elements = await robot.getElementsOnScreen();
         const result = elements.map(element => {
@@ -312,7 +319,7 @@ const createMcpServer = () => {
     tool("mobile_press_button", "Press Button", "Press a button on device", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         button: zod_1.z.string().describe("The button to press. Supported buttons: BACK (android only), HOME, VOLUME_UP, VOLUME_DOWN, ENTER, DPAD_CENTER (android tv only), DPAD_UP (android tv only), DPAD_DOWN (android tv only), DPAD_LEFT (android tv only), DPAD_RIGHT (android tv only)"),
-    }, async ({ device, button }) => {
+    }, { destructiveHint: true }, async ({ device, button }) => {
         const robot = getRobotFromDevice(device);
         await robot.pressButton(button);
         return `Pressed the button: ${button}`;
@@ -320,7 +327,7 @@ const createMcpServer = () => {
     tool("mobile_open_url", "Open URL", "Open a URL in browser on device", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         url: zod_1.z.string().describe("The URL to open"),
-    }, async ({ device, url }) => {
+    }, { destructiveHint: true }, async ({ device, url }) => {
         const robot = getRobotFromDevice(device);
         await robot.openUrl(url);
         return `Opened URL: ${url}`;
@@ -331,7 +338,7 @@ const createMcpServer = () => {
         x: zod_1.z.number().optional().describe("The x coordinate to start the swipe from, in pixels. If not provided, uses center of screen"),
         y: zod_1.z.number().optional().describe("The y coordinate to start the swipe from, in pixels. If not provided, uses center of screen"),
         distance: zod_1.z.number().optional().describe("The distance to swipe in pixels. Defaults to 400 pixels for iOS or 30% of screen dimension for Android"),
-    }, async ({ device, direction, x, y, distance }) => {
+    }, { destructiveHint: true }, async ({ device, direction, x, y, distance }) => {
         const robot = getRobotFromDevice(device);
         if (x !== undefined && y !== undefined) {
             // Use coordinate-based swipe
@@ -349,7 +356,7 @@ const createMcpServer = () => {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         text: zod_1.z.string().describe("The text to type"),
         submit: zod_1.z.boolean().describe("Whether to submit the text. If true, the text will be submitted as if the user pressed the enter key."),
-    }, async ({ device, text, submit }) => {
+    }, { destructiveHint: true }, async ({ device, text, submit }) => {
         const robot = getRobotFromDevice(device);
         await robot.sendKeys(text);
         if (submit) {
@@ -360,7 +367,7 @@ const createMcpServer = () => {
     tool("mobile_save_screenshot", "Save Screenshot", "Save a screenshot of the mobile device to a file", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         saveTo: zod_1.z.string().describe("The path to save the screenshot to"),
-    }, async ({ device, saveTo }) => {
+    }, { destructiveHint: true }, async ({ device, saveTo }) => {
         const robot = getRobotFromDevice(device);
         const screenshot = await robot.getScreenshot();
         node_fs_1.default.writeFileSync(saveTo, screenshot);
@@ -371,7 +378,10 @@ const createMcpServer = () => {
         description: "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.",
         inputSchema: {
             device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
-        }
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
     }, async ({ device }) => {
         try {
             const robot = getRobotFromDevice(device);
@@ -419,14 +429,14 @@ const createMcpServer = () => {
     tool("mobile_set_orientation", "Set Orientation", "Change the screen orientation of the device", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you."),
         orientation: zod_1.z.enum(["portrait", "landscape"]).describe("The desired orientation"),
-    }, async ({ device, orientation }) => {
+    }, { destructiveHint: true }, async ({ device, orientation }) => {
         const robot = getRobotFromDevice(device);
         await robot.setOrientation(orientation);
         return `Changed device orientation to ${orientation}`;
     });
     tool("mobile_get_orientation", "Get Orientation", "Get the current screen orientation of the device", {
         device: zod_1.z.string().describe("The device identifier to use. Use mobile_list_available_devices to find which devices are available to you.")
-    }, async ({ device }) => {
+    }, { readOnlyHint: true }, async ({ device }) => {
         const robot = getRobotFromDevice(device);
         const orientation = await robot.getOrientation();
         return `Current device orientation is ${orientation}`;

package/lib/webdriver-agent.js

@@ -172,7 +172,7 @@ class WebDriverAgent {
             });
         });
     }
-    async longPress(x, y) {
+    async longPress(x, y, duration) {
         await this.withinSession(async (sessionUrl) => {
             const url = `${sessionUrl}/actions`;
             await fetch(url, {
@@ -189,7 +189,7 @@ class WebDriverAgent {
                             actions: [
                                 { type: "pointerMove", duration: 0, x, y },
                                 { type: "pointerDown", button: 0 },
-                                { type: "pause", duration: 500 },
+                                { type: "pause", duration },
                                 { type: "pointerUp", button: 0 }
                             ]
                         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mobilenext/mobile-mcp",
   "mcpName": "io.github.mobile-next/mobile-mcp",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "description": "Mobile MCP",
   "repository": {
     "type": "git",
@@ -32,7 +32,7 @@
     "zod-to-json-schema": "3.25.0"
   },
   "optionalDependencies": {
-    "@mobilenext/mobilecli": "0.0.38"
+    "@mobilenext/mobilecli": "0.0.49"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",