@mobilenext/mobile-mcp 0.0.6

package/README.md

@@ -0,0 +1,172 @@
+## Mobile Next - MCP server for Mobile Automation
+
+This is a [Model Context Protocol (MCP) server](https://github.com/modelcontextprotocol) that provides mobile automation capabilities powered by [Appium](https://github.com/appium). 
+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. 
+
+<p align="center">
+    <a href="https://github.com/mobile-next/">
+        <img alt="mobile-mcp" src="https://github.com/mobile-next/mobile-next-assets/blob/main/mobile-mcp-banner.png?raw=true" width="600">
+    </a>
+</p>
+
+### 🚀 Mobile MCP Roadmap: Building the Future of Mobile
+
+Join us on our journey as we continuously enhance Mobile MCP! 
+Check out our detailed roadmap to see upcoming features, improvements, and milestones. Your feedback is invaluable in shaping the future of mobile automation.
+
+👉 [Explore the Roadmap](https://github.com/orgs/mobile-next/projects/1)
+
+### Main use cases
+
+How we help to scale mobile automation:
+
+- 📲 Native app automation (iOS and Android) for testing or data-entry scenarios. 
+- 📝 Scripted flows and form interactions without manually controlling simulators/emulators or physical devices (iPhone, Samsung, Google Pixel etc)
+- 🧭 Automating multi-step user journeys driven by an LLM
+- 👆 General-purpose mobile application interaction for agent-based frameworks
+- 🤖 Enables agent-to-agent communication for mobile automation usecases, data extraction
+
+## Main Features
+
+- 🚀 **Fast and lightweight**: Uses native accessibility trees for most interactions, or screenshot based coordinates where a11y labels are not available. 
+- 🤖 **LLM-friendly**: No computer vision model required in Accessibility (Snapshot).
+- 🧿 **Visual Sense**: Evaluates and analyses what’s actually rendered on screen to decide the next action. If accessibility data or view-hierarchy coordinates are unavailable, it falls back to screenshot-based analysis.
+- 📊 **Deterministic tool application**: Reduces ambiguity found in purely screenshot-based approaches by relying on structured data whenever possible.
+- 📺 **Extract structured data**: Enables you to extract structred data from anything visible on screen. 
+
+## Mobile MCP Architecture
+
+<p align="center">
+    <a href="/images/mobile-mcp-arch.png">
+        <img alt="mobile-mcp" src="https://github.com/mobile-next/mobile-next-assets/blob/main/mobile-mcp-arch.png?raw=true" width="600">
+    </a>
+</p>
+
+
+
+## How to install
+
+```js
+{
+  "mcpServers": {
+    "mobile-next": {
+      "command": "npx",
+      "args": [
+        "@mobile-next/appium-mcp@latest"
+      ]
+    }
+  }
+}
+```
+
+## Prerequisites
+
+What you will need to connect MCP with your agent and mobile devices:
+
+- [Xcode command line tools](https://developer.apple.com/xcode/resources/)
+- [Android Platform Tools](https://developer.android.com/tools/releases/platform-tools)
+- [node.js](https://nodejs.org/en/download/)
+- [MCP](https://modelcontextprotocol.io/introduction) supported foundational models or agents, like [Claude MCP](https://modelcontextprotocol.io/quickstart/server), [OpenAI Agent SDK](https://openai.github.io/openai-agents-python/mcp/), [Copilot Studio](https://www.microsoft.com/en-us/microsoft-copilot/blog/copilot-studio/introducing-model-context-protocol-mcp-in-copilot-studio-simplified-integration-with-ai-apps-and-agents/)
+
+### Simulators, Emulators, and Physical Devices
+
+When launched, Appium MCP can connect to:
+	•	iOS Simulators on macOS/Linux
+	•	Android Emulators on Linux/Windows/macOS
+	•	Physical iOS or Android devices (requires proper platform tools and drivers)
+
+Make sure you have your mobile platform SDKs (Xcode, Android SDK) installed and configured properly before running Mobile Next Appium MCP.
+
+
+### Running in "headless" mode on Simulators/Emulators
+
+When you do not have an actual phone connected, you can run Mobile Next Appium MCP with an emulator or simulator in the background.
+
+For example, on Android:
+	1.	Start an emulator (avdmanager / emulator command).
+	2.	Run Appium MCP with the desired flags
+
+On iOS, you'll need Xcode and to run the Simulator before using Appium MCP with that simulator instance.
+`xcrun simctl list`
+`xcrun simctl boot "iPhone 16"`
+
+
+# Mobile Commands and interaction tools
+
+These tools use accessibility-based element references on iOS or Android. By relying on the accessibility/automation IDs, you avoid the ambiguity of coordinate-based approaches.
+
+## mobile_install_app
+- **Description:** Installs an app onto the device/emulator
+- **Parameters:**
+  - `appPath` (string): Path or URL to the app file (e.g., .apk for Android, .ipa/.app for iOS)
+
+## mobile_launch_app
+- **Description:** Launches the specified app on the device/emulator
+- **Parameters:**
+  - `bundleId` (string): The application's unique bundle/package identifier like: com.google.android.keep	 or com.apple.mobilenotes )
+
+## mobile_terminate_app
+- **Description:** Terminates a running application
+- **Parameters:**
+  - `bundleId` (string): The application's bundle/package identifier
+
+## mobile_element_tap
+- **Description:** Taps on a UI element identified by accessibility locator
+- **Parameters:**
+  - `element` (string): Human-readable element description (e.g., "Login button")
+  - `ref` (string): Accessibility/automation ID or reference from a snapshot
+
+## mobile_tap
+- **Description:** Taps on specified screen coordinates
+- **Parameters:**
+  - `x` (number): X-coordinate
+  - `y` (number): Y-coordinate
+
+## mobile_element_send_keys
+- **Description:** Types text into a UI element (e.g., TextField)
+- **Parameters:**
+  - `element` (string): Human-readable element description
+  - `ref` (string): Accessibility/automation ID of the element
+  - `text` (string): Text to type
+  - `submit` (boolean): Whether to press Enter/Return after typing
+
+## mobile_element_swipe
+- **Description:** Performs a swipe gesture from one UI element to another
+- **Parameters:**
+  - `startElement` (string): Human-readable description of the start element
+  - `startRef` (string): Accessibility/automation ID of the start element
+  - `endElement` (string): Human-readable description of the end element
+  - `endRef` (string): Accessibility/automation ID of the end element
+ 
+## mobile_swipe
+- **Description:** Performs a swipe gesture between two sets of screen coordinates
+- **Parameters:**
+  - `startX` (number): Start X-coordinate
+  - `startY` (number): Start Y-coordinate
+  - `endX` (number): End X-coordinate
+  - `endY` (number): End Y-coordinate
+
+## mobile_press_key
+- **Description:** Presses hardware keys or triggers special events (e.g., back button on Android)
+- **Parameters:**
+  - `key` (string): Key identifier (e.g., HOME, BACK, VOLUME_UP, etc.)
+
+## mobile_take_screenshot
+- **Description:** Captures a screenshot of the current device screen
+- **Parameters:**
+  - `raw` (boolean): Return a lossless image if true; otherwise, compressed by default
+
+## mobile_get_source
+- **Description:** Fetches the current device UI structure (accessibility snapshot) (xml format)
+- **Parameters:** None
+
+## mobile_wait
+- **Description:** Waits for a specified time
+- **Parameters:**
+  - `time` (number): Time to wait in seconds (capped at 10 seconds)
+
+## mobile_close_session
+- **Description:** Closes the current Appium session
+- **Parameters:** None
+
+

package/lib/android.js

@@ -0,0 +1,171 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listApps = exports.takeScreenshot = exports.swipe = exports.getElementsOnScreen = exports.getScreenSize = exports.resolveLaunchableActivities = exports.getConnectedDevices = 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 [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),
+        };
+    };
+    const normalizeCoordinates = (coordinates, screenSize) => {
+        return {
+            x: Number((coordinates.x / screenSize[0]).toFixed(3)),
+            y: Number((coordinates.y / screenSize[1]).toFixed(3)),
+        };
+    };
+    if (node.node) {
+        if (Array.isArray(node.node)) {
+            for (const childNode of node.node) {
+                elements.push(...collectElements(childNode, screenSize));
+            }
+        }
+        else {
+            elements.push(...collectElements(node.node, screenSize));
+        }
+    }
+    if (node.text) {
+        elements.push({
+            "text": node.text,
+            "coordinates": normalizeCoordinates(getCenter(getCoordinates(node)), screenSize),
+        });
+    }
+    if (node["content-desc"]) {
+        elements.push({
+            "text": node["content-desc"],
+            "coordinates": normalizeCoordinates(getCenter(getCoordinates(node)), screenSize),
+        });
+    }
+    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 "down":
+            x0 = x1 = centerX;
+            y0 = Math.floor(screenSize[1] * 0.80);
+            y1 = Math.floor(screenSize[1] * 0.20);
+            break;
+        case "up":
+            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`);
+    }
+    (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`)
+        .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;
+};
+exports.listApps = listApps;

package/lib/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const server_1 = require("./server");
+const logger_1 = require("./logger");
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    const server = (0, server_1.createMcpServer)();
+    await server.connect(transport);
+    (0, logger_1.error)("Appium MCP Server running on stdio");
+}
+main().catch(err => {
+    console.error("Fatal error in main():", err);
+    (0, logger_1.error)("Fatal error in main(): " + JSON.stringify(err.stack));
+    process.exit(1);
+});

package/lib/iphone-simulator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listApps = exports.launchApp = exports.openUrl = exports.getScreenshot = exports.getConnectedDevices = 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 => {
+        // extract device name and UUID from the line
+        const match = line.match(/(.*?)\s+\(([\w-]+)\)\s+\(Booted\)/);
+        if (!match) {
+            return null;
+        }
+        const deviceName = match[1].trim();
+        const deviceUuid = match[2];
+        return {
+            name: deviceName,
+            uuid: deviceUuid,
+        };
+    })
+        .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;

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/server.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 getAgentVersion = () => {
+    const json = require("../package.json");
+    return json.version;
+};
+const createMcpServer = () => {
+    const server = new mcp_js_1.McpServer({
+        name: "appium-mcp",
+        version: getAgentVersion(),
+        capabilities: {
+            resources: {},
+            tools: {},
+        },
+    });
+    const tool = (name, description, paramsSchema, cb) => {
+        const wrappedCb = async (args) => {
+            try {
+                (0, logger_1.trace)(`Invoking ${name} with args: ${JSON.stringify(args)}`);
+                const response = await cb(args);
+                (0, logger_1.trace)(`=> ${response}`);
+                return {
+                    content: [{ type: "text", text: response }],
+                };
+            }
+            catch (error) {
+                (0, logger_1.trace)(`Tool '${description}' failed: ${error.message} stack: ${error.stack}`);
+                return {
+                    content: [{ type: "text", text: `Error: ${error.message}` }],
+                    isError: true,
+                };
+            }
+        };
+        server.tool(name, description, paramsSchema, args => wrappedCb(args));
+    };
+    tool("list-apps-on-device", "List all apps on device", {}, async ({}) => {
+        /*
+        const result = execSync(`adb shell pm list packages`)
+            .toString()
+            .split("\n")
+            .filter(line => line.startsWith("package:"))
+            .map(line => line.substring("package:".length));
+        */
+        const result = (0, android_1.listApps)();
+        return `Found these packages on device: ${result.join(",")}`;
+    });
+    tool("launch-app", "Launch an app on mobile 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`);
+        return `Launched 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("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}`);
+        return `Clicked on screen at coordinates: ${x}, ${y}`;
+    });
+    tool("list-elements-on-screen", "List elements on screen and their coordinates, based on text or accessibility label", {}, async ({}) => {
+        const elements = (0, android_1.getElementsOnScreen)();
+        return `Found these elements on screen: ${JSON.stringify(elements)}`;
+    });
+    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"),
+    }, async ({ button }) => {
+        (0, child_process_1.execSync)(`adb shell input keyevent ${button}`);
+        return `Pressed the button: ${button}`;
+    });
+    tool("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}"`);
+        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);
+        return `Swiped ${direction} on screen`;
+    });
+    tool("type-text", "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}"`);
+        return `Typed text: ${text}`;
+    });
+    server.tool("take-device-screenshot", "Take a screenshot of the mobile device", {}, async ({}) => {
+        try {
+            const screenshot = await (0, android_1.takeScreenshot)();
+            // Scale down the screenshot by 50%
+            const image = (0, sharp_1.default)(screenshot);
+            const metadata = await image.metadata();
+            if (!metadata.width) {
+                throw new Error("Failed to get screenshot metadata");
+            }
+            const resizedScreenshot = await image
+                .resize(Math.floor(metadata.width / 2))
+                .jpeg({ quality: 75 })
+                .toBuffer();
+            // debug:
+            // writeFileSync('/tmp/screenshot.png', screenshot);
+            // writeFileSync('/tmp/screenshot-scaled.jpg', resizedScreenshot);
+            const screenshot64 = resizedScreenshot.toString("base64");
+            (0, logger_1.trace)(`Screenshot taken: ${screenshot.length} bytes`);
+            return {
+                content: [{ type: "image", data: screenshot64, mimeType: "image/jpeg" }]
+            };
+        }
+        catch (err) {
+            (0, logger_1.error)(`Error taking screenshot: ${err.message} ${err.stack}`);
+            return {
+                content: [{ type: "text", text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    });
+    return server;
+};
+exports.createMcpServer = createMcpServer;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@mobilenext/mobile-mcp",
+  "version": "0.0.6",
+  "description": "Mobile MCP",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mobile-next/mobile-mcp.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint .",
+    "watch": "tsc --watch",
+    "clean": "rm -rf lib"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.1",
+    "fast-xml-parser": "^5.0.9",
+    "sharp": "^0.33.5",
+    "zod-to-json-schema": "^3.24.4"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.19.0",
+    "@stylistic/eslint-plugin": "^3.0.1",
+    "@types/node": "^22.13.10",
+    "@typescript-eslint/eslint-plugin": "^8.28.0",
+    "@typescript-eslint/parser": "^8.26.1",
+    "@typescript-eslint/utils": "^8.26.1",
+    "eslint": "^9.19.0",
+    "eslint-plugin": "^1.0.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-notice": "^1.0.0",
+    "typescript": "^5.8.2"
+  },
+  "main": "index.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "author": "",
+  "bugs": {
+    "url": "https://github.com/mobile-next/mobile-mcp/issues"
+  },
+  "homepage": "https://github.com/mobile-next/mobile-mcp#readme"
+}