@ggboi360/mobile-dev-mcp 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,2300 +1,976 @@
 #!/usr/bin/env node
+/**
+ * Mobile Dev MCP - Read-Only Debugging Tools for Mobile Development
+ *
+ * A read-only MCP server for observing and debugging mobile apps:
+ * - Taking screenshots
+ * - Viewing device information
+ * - Reading logs
+ * - Inspecting UI hierarchy
+ * - Analyzing screen content
+ *
+ * License: Dual (MIT + Elastic License 2.0)
+ */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { exec, spawn } from "child_process";
-import { promisify } from "util";
-import * as fs from "fs";
-import * as path from "path";
-import * as http from "http";
-import WebSocket from "ws";
-// License module
-import { checkLicense, requireAdvanced, requireBasic, licenseTools, handleLicenseTool, loadConfig, TIER_LIMITS, } from "./license.js";
-const execAsync = promisify(exec);
-// Configuration (loaded from user config)
+import { ADB, XCRUN, execAsync, sleep, parseUiTree, findElementInTree, captureAndroidScreenshot, captureIosScreenshot, listConnectedDevices, loadConfig, validateDeviceId, validatePackageName, validateUdid, validateLogFilter, validateLogLevel, } from "./utils.js";
+import { checkLicense, canAccessTool, getMaxLogLines, getMaxDevices, getLicenseStatus, setLicenseKey, } from "./license.js";
+// ============================================================================
+// CONFIG
+// ============================================================================
 const userConfig = loadConfig();
 const CONFIG = {
     metroPort: userConfig.metroPort || 8081,
-    logBufferSize: userConfig.logBufferSize || 100,
     screenshotDir: process.env.TEMP || "/tmp",
 };
-// Log buffers
-let metroLogBuffer = [];
-let adbLogBuffer = [];
-let metroProcess = null;
-let adbLogProcess = null;
-// Screenshot history for Pro users
-let screenshotHistory = [];
-const MAX_SCREENSHOT_HISTORY = 20;
 // ============================================================================
-// TOOL DEFINITIONS
+// TOOL DEFINITIONS (21 tools)
 // ============================================================================
-const coreTools = [
-    // === FREE TIER TOOLS ===
-    {
-        name: "get_metro_logs",
-        description: "Get recent logs from Metro bundler. Returns the last N lines of Metro output. Useful for seeing build errors, warnings, and bundle status.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                lines: {
-                    type: "number",
-                    description: "Number of log lines to retrieve (default: 50, max: 50 for free tier)",
-                    default: 50,
-                },
-                filter: {
-                    type: "string",
-                    description: "Optional filter string to match (e.g., 'error', 'warning')",
-                },
-            },
-        },
-    },
-    {
-        name: "get_adb_logs",
-        description: "Get logs from Android device/emulator via ADB logcat. Filters for React Native and JavaScript logs by default.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                lines: {
-                    type: "number",
-                    description: "Number of log lines to retrieve (default: 50, max: 50 for free tier)",
-                    default: 50,
-                },
-                filter: {
-                    type: "string",
-                    description: "Tag filter for logcat (default: 'ReactNativeJS'). Use '*' for all logs.",
-                    default: "ReactNativeJS",
-                },
-                level: {
-                    type: "string",
-                    enum: ["V", "D", "I", "W", "E", "F"],
-                    description: "Minimum log level: V(erbose), D(ebug), I(nfo), W(arn), E(rror), F(atal)",
-                    default: "I",
-                },
-            },
-        },
-    },
+const tools = [
+    // === FREE TIER - Screenshots (2 tools) ===
     {
         name: "screenshot_emulator",
-        description: "Capture a screenshot from the currently running Android emulator. Returns the screenshot as a base64-encoded image.",
+        description: "Capture a screenshot from the currently running Android emulator. Returns base64-encoded PNG image.",
         inputSchema: {
             type: "object",
             properties: {
                 device: {
                     type: "string",
-                    description: "Specific device ID (from 'adb devices'). Leave empty for default device.",
+                    description: "Specific device ID. Leave empty for default device.",
                 },
             },
         },
     },
     {
-        name: "list_devices",
-        description: "List all connected Android devices and emulators via ADB. Shows device IDs and status.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-        },
-    },
-    {
-        name: "check_metro_status",
-        description: "Check if Metro bundler is running and get its current status. Returns bundle status and any pending builds.",
+        name: "screenshot_ios_simulator",
+        description: "Capture a screenshot from an iOS Simulator. Returns base64-encoded PNG image.",
         inputSchema: {
             type: "object",
             properties: {
-                port: {
-                    type: "number",
-                    description: "Metro port (default: 8081)",
-                    default: 8081,
+                udid: {
+                    type: "string",
+                    description: "Simulator UDID. Leave empty for booted simulator.",
                 },
             },
         },
     },
+    // === FREE TIER - Device Info (5 tools) ===
     {
-        name: "get_app_info",
-        description: "Get information about an installed app on the Android device, including version and permissions.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                packageName: {
-                    type: "string",
-                    description: "The app package name (e.g., 'com.myapp' or 'host.exp.exponent')",
-                },
-            },
-            required: ["packageName"],
-        },
+        name: "list_devices",
+        description: "List all connected Android devices and emulators via ADB.",
+        inputSchema: { type: "object", properties: {} },
     },
     {
-        name: "clear_app_data",
-        description: "Clear app data and cache on Android device. Useful for testing fresh installs.",
+        name: "list_ios_simulators",
+        description: "List all available iOS Simulators with state and iOS version.",
         inputSchema: {
             type: "object",
             properties: {
-                packageName: {
-                    type: "string",
-                    description: "The app package name to clear data for",
+                onlyBooted: {
+                    type: "boolean",
+                    description: "Only show booted simulators (default: false)",
+                    default: false,
                 },
             },
-            required: ["packageName"],
-        },
-    },
-    {
-        name: "restart_adb",
-        description: "Restart the ADB server. Useful when ADB becomes unresponsive or devices are not detected.",
-        inputSchema: {
-            type: "object",
-            properties: {},
         },
     },
     {
         name: "get_device_info",
-        description: "Get detailed information about the connected Android device including OS version, screen size, and available memory.",
+        description: "Get detailed information about connected Android device (OS version, screen size, memory).",
         inputSchema: {
             type: "object",
             properties: {
                 device: {
                     type: "string",
-                    description: "Specific device ID. Leave empty for default device.",
+                    description: "Specific device ID. Leave empty for default.",
                 },
             },
         },
     },
     {
-        name: "start_metro_logging",
-        description: "Start capturing Metro bundler logs by watching a log file. Point this at your Metro output file or pipe Metro to a file.",
+        name: "get_ios_simulator_info",
+        description: "Get detailed information about an iOS Simulator.",
         inputSchema: {
             type: "object",
             properties: {
-                logFile: {
+                udid: {
                     type: "string",
-                    description: "Path to Metro log file to watch. If not provided, will try common locations.",
+                    description: "Simulator UDID. Leave empty for booted simulator.",
                 },
             },
         },
     },
     {
-        name: "stop_metro_logging",
-        description: "Stop the background Metro log capture.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-        },
-    },
-    // === PRO TIER TOOLS ===
-    {
-        name: "stream_adb_realtime",
-        description: "[PRO] Start real-time ADB log streaming. Logs are continuously captured in the background.",
+        name: "get_app_info",
+        description: "Get information about an installed app on Android device.",
         inputSchema: {
             type: "object",
             properties: {
-                filter: {
+                packageName: {
                     type: "string",
-                    description: "Tag filter for logcat (default: 'ReactNativeJS')",
-                    default: "ReactNativeJS",
+                    description: "The app package name (e.g., 'com.myapp')",
                 },
             },
+            required: ["packageName"],
         },
     },
+    // === FREE TIER - Logs (4 tools) ===
     {
-        name: "stop_adb_streaming",
-        description: "[PRO] Stop real-time ADB log streaming.",
-        inputSchema: {
-            type: "object",
-            properties: {},
-        },
-    },
-    {
-        name: "screenshot_history",
-        description: "[PRO] Get previously captured screenshots. Stores up to 20 screenshots.",
+        name: "get_metro_logs",
+        description: "Get recent logs from Metro bundler. Useful for build errors and warnings.",
         inputSchema: {
             type: "object",
             properties: {
-                count: {
+                lines: {
                     type: "number",
-                    description: "Number of recent screenshots to retrieve (default: 5)",
-                    default: 5,
-                },
-            },
-        },
-    },
-    {
-        name: "watch_for_errors",
-        description: "[PRO] Start watching logs for specific error patterns. Returns when an error is detected.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                patterns: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Error patterns to watch for (e.g., ['Error', 'Exception', 'crash'])",
+                    description: "Number of lines (default: 50, limit varies by tier)",
+                    default: 50,
                 },
-                timeout: {
-                    type: "number",
-                    description: "Timeout in seconds (default: 60)",
-                    default: 60,
+                filter: {
+                    type: "string",
+                    description: "Optional filter string (e.g., 'error', 'warning')",
                 },
             },
         },
     },
     {
-        name: "multi_device_logs",
-        description: "[PRO] Get logs from multiple devices simultaneously.",
+        name: "get_adb_logs",
+        description: "Get logs from Android device via ADB logcat. Filters for React Native by default.",
         inputSchema: {
             type: "object",
             properties: {
-                devices: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Array of device IDs to get logs from",
-                },
                 lines: {
                     type: "number",
-                    description: "Number of log lines per device",
-                    default: 30,
-                },
-            },
-        },
-    },
-    // === INTERACTION TOOLS (Advanced) ===
-    {
-        name: "tap_screen",
-        description: "[PRO] Tap on the screen at specific coordinates. Use this to interact with UI elements.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                x: {
-                    type: "number",
-                    description: "X coordinate to tap",
-                },
-                y: {
-                    type: "number",
-                    description: "Y coordinate to tap",
-                },
-                device: {
-                    type: "string",
-                    description: "Specific device ID (optional)",
+                    description: "Number of lines (default: 50, limit varies by tier)",
+                    default: 50,
                 },
-            },
-            required: ["x", "y"],
-        },
-    },
-    {
-        name: "input_text",
-        description: "[PRO] Type text into the currently focused input field.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                text: {
+                filter: {
                     type: "string",
-                    description: "Text to type",
+                    description: "Tag filter (default: 'ReactNativeJS'). Use '*' for all.",
+                    default: "ReactNativeJS",
                 },
-                device: {
+                level: {
                     type: "string",
-                    description: "Specific device ID (optional)",
+                    enum: ["V", "D", "I", "W", "E", "F"],
+                    description: "Minimum log level",
+                    default: "I",
                 },
             },
-            required: ["text"],
         },
     },
     {
-        name: "press_button",
-        description: "[PRO] Press a hardware button (back, home, recent apps, volume, power).",
+        name: "get_ios_simulator_logs",
+        description: "Get recent logs from iOS Simulator.",
         inputSchema: {
             type: "object",
             properties: {
-                button: {
+                lines: {
+                    type: "number",
+                    description: "Number of lines (default: 50)",
+                    default: 50,
+                },
+                filter: {
                     type: "string",
-                    enum: ["back", "home", "recent", "volume_up", "volume_down", "power", "enter"],
-                    description: "Button to press",
+                    description: "Filter logs by subsystem or content",
                 },
-                device: {
+                udid: {
                     type: "string",
-                    description: "Specific device ID (optional)",
+                    description: "Simulator UDID. Leave empty for booted simulator.",
                 },
             },
-            required: ["button"],
         },
     },
     {
-        name: "swipe_screen",
-        description: "[PRO] Swipe on the screen from one point to another. Use for scrolling or gestures.",
+        name: "check_metro_status",
+        description: "Check if Metro bundler is running and get its status.",
         inputSchema: {
             type: "object",
             properties: {
-                startX: {
-                    type: "number",
-                    description: "Starting X coordinate",
-                },
-                startY: {
-                    type: "number",
-                    description: "Starting Y coordinate",
-                },
-                endX: {
-                    type: "number",
-                    description: "Ending X coordinate",
-                },
-                endY: {
-                    type: "number",
-                    description: "Ending Y coordinate",
-                },
-                duration: {
+                port: {
                     type: "number",
-                    description: "Swipe duration in milliseconds (default: 300)",
-                    default: 300,
-                },
-                device: {
-                    type: "string",
-                    description: "Specific device ID (optional)",
+                    description: "Metro port (default: 8081)",
+                    default: 8081,
                 },
             },
-            required: ["startX", "startY", "endX", "endY"],
         },
     },
+    // === FREE TIER - License (1 tool) ===
     {
-        name: "launch_app",
-        description: "[PRO] Launch an app by its package name.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                packageName: {
-                    type: "string",
-                    description: "Package name of the app (e.g., 'com.example.myapp')",
-                },
-                device: {
-                    type: "string",
-                    description: "Specific device ID (optional)",
-                },
-            },
-            required: ["packageName"],
-        },
+        name: "get_license_status",
+        description: "Get your current license tier and available features.",
+        inputSchema: { type: "object", properties: {} },
     },
+    // === ADVANCED TIER - UI Inspection (5 tools) ===
     {
-        name: "install_apk",
-        description: "[PRO] Install an APK file to the device.",
+        name: "get_ui_tree",
+        description: "[ADVANCED] Get the current UI hierarchy from Android device. Returns all visible elements with text, bounds, and properties.",
         inputSchema: {
             type: "object",
             properties: {
-                apkPath: {
-                    type: "string",
-                    description: "Path to the APK file",
-                },
                 device: {
                     type: "string",
                     description: "Specific device ID (optional)",
                 },
-            },
-            required: ["apkPath"],
-        },
-    },
-    // === iOS SIMULATOR TOOLS ===
-    {
-        name: "list_ios_simulators",
-        description: "List all available iOS Simulators. Shows device name, UDID, state (Booted/Shutdown), and iOS version.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                onlyBooted: {
+                compressed: {
                     type: "boolean",
-                    description: "Only show booted simulators (default: false)",
-                    default: false,
+                    description: "Return only interactive elements (default: true)",
+                    default: true,
                 },
             },
         },
     },
     {
-        name: "screenshot_ios_simulator",
-        description: "Capture a screenshot from an iOS Simulator. Returns the screenshot as a base64-encoded image.",
+        name: "find_element",
+        description: "[ADVANCED] Find a UI element by text, resource ID, or content description.",
         inputSchema: {
             type: "object",
             properties: {
-                udid: {
-                    type: "string",
-                    description: "Simulator UDID. Leave empty for the booted simulator.",
-                },
+                text: { type: "string", description: "Element text to find" },
+                resourceId: { type: "string", description: "Resource ID to find" },
+                contentDescription: { type: "string", description: "Accessibility label" },
+                device: { type: "string", description: "Specific device ID (optional)" },
             },
         },
     },
     {
-        name: "get_ios_simulator_logs",
-        description: "Get recent logs from an iOS Simulator. Useful for debugging React Native iOS apps.",
+        name: "wait_for_element",
+        description: "[ADVANCED] Wait for a UI element to appear on screen.",
         inputSchema: {
             type: "object",
             properties: {
-                udid: {
-                    type: "string",
-                    description: "Simulator UDID. Leave empty for the booted simulator.",
-                },
-                filter: {
-                    type: "string",
-                    description: "Filter logs by subsystem or message content",
-                },
-                lines: {
+                text: { type: "string", description: "Element text to wait for" },
+                resourceId: { type: "string", description: "Resource ID to wait for" },
+                contentDescription: { type: "string", description: "Accessibility label" },
+                timeout: {
                     type: "number",
-                    description: "Number of recent log lines (default: 50)",
-                    default: 50,
-                },
-            },
-        },
-    },
-    {
-        name: "get_ios_simulator_info",
-        description: "Get detailed information about an iOS Simulator including device type, iOS version, and state.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                udid: {
-                    type: "string",
-                    description: "Simulator UDID. Leave empty for the booted simulator.",
-                },
-            },
-        },
-    },
-    {
-        name: "boot_ios_simulator",
-        description: "[PRO] Boot an iOS Simulator by UDID or device name.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                udid: {
-                    type: "string",
-                    description: "Simulator UDID or device name (e.g., 'iPhone 15 Pro')",
+                    description: "Maximum wait time in ms (default: 5000)",
+                    default: 5000,
                 },
+                device: { type: "string", description: "Specific device ID (optional)" },
             },
-            required: ["udid"],
         },
     },
     {
-        name: "shutdown_ios_simulator",
-        description: "[PRO] Shutdown an iOS Simulator.",
+        name: "get_element_property",
+        description: "[ADVANCED] Get a specific property of a UI element.",
         inputSchema: {
             type: "object",
             properties: {
-                udid: {
+                text: { type: "string", description: "Element text to find" },
+                resourceId: { type: "string", description: "Resource ID to find" },
+                property: {
                     type: "string",
-                    description: "Simulator UDID. Use 'all' to shutdown all simulators.",
+                    enum: ["text", "enabled", "checked", "selected", "focused", "clickable", "scrollable"],
+                    description: "Property to retrieve",
                 },
+                device: { type: "string", description: "Specific device ID (optional)" },
             },
-            required: ["udid"],
+            required: ["property"],
         },
     },
     {
-        name: "install_ios_app",
-        description: "[PRO] Install an app (.app bundle) on an iOS Simulator.",
+        name: "assert_element",
+        description: "[ADVANCED] Verify a UI element exists or has expected state.",
         inputSchema: {
             type: "object",
             properties: {
-                appPath: {
-                    type: "string",
-                    description: "Path to the .app bundle",
-                },
-                udid: {
-                    type: "string",
-                    description: "Simulator UDID. Leave empty for the booted simulator.",
+                text: { type: "string", description: "Element text to verify" },
+                resourceId: { type: "string", description: "Resource ID to verify" },
+                shouldExist: {
+                    type: "boolean",
+                    description: "Whether element should exist (default: true)",
+                    default: true,
                 },
+                isEnabled: { type: "boolean", description: "Expected enabled state" },
+                isChecked: { type: "boolean", description: "Expected checked state" },
+                device: { type: "string", description: "Specific device ID (optional)" },
             },
-            required: ["appPath"],
         },
     },
+    // === ADVANCED TIER - Screen Analysis (3 tools) ===
     {
-        name: "launch_ios_app",
-        description: "[PRO] Launch an app on an iOS Simulator by bundle identifier.",
+        name: "suggest_action",
+        description: "[ADVANCED] Analyze the screen and suggest what action to take based on the current UI state. Returns suggestions without executing.",
         inputSchema: {
             type: "object",
             properties: {
-                bundleId: {
-                    type: "string",
-                    description: "App bundle identifier (e.g., 'com.example.myapp')",
-                },
-                udid: {
+                goal: {
                     type: "string",
-                    description: "Simulator UDID. Leave empty for the booted simulator.",
+                    description: "What you're trying to accomplish (e.g., 'login', 'send message', 'navigate to settings')",
                 },
+                device: { type: "string", description: "Specific device ID" },
             },
-            required: ["bundleId"],
+            required: ["goal"],
         },
     },
     {
-        name: "terminate_ios_app",
-        description: "[PRO] Terminate (force quit) an app on an iOS Simulator.",
+        name: "analyze_screen",
+        description: "[ADVANCED] Get a detailed analysis of what's currently on the screen.",
         inputSchema: {
             type: "object",
             properties: {
-                bundleId: {
-                    type: "string",
-                    description: "App bundle identifier to terminate",
-                },
-                udid: {
-                    type: "string",
-                    description: "Simulator UDID. Leave empty for the booted simulator.",
-                },
+                device: { type: "string", description: "Specific device ID" },
             },
-            required: ["bundleId"],
         },
     },
     {
-        name: "ios_open_url",
-        description: "[PRO] Open a URL in the iOS Simulator (deep links, universal links).",
+        name: "get_screen_text",
+        description: "[ADVANCED] Extract all visible text from the current screen.",
         inputSchema: {
             type: "object",
             properties: {
-                url: {
-                    type: "string",
-                    description: "URL to open (e.g., 'myapp://screen' or 'https://example.com')",
-                },
-                udid: {
-                    type: "string",
-                    description: "Simulator UDID. Leave empty for the booted simulator.",
-                },
+                device: { type: "string", description: "Specific device ID" },
             },
-            required: ["url"],
         },
     },
+    // === ADVANCED TIER - License (1 tool) ===
     {
-        name: "ios_push_notification",
-        description: "[PRO] Send a push notification to an iOS Simulator.",
+        name: "set_license_key",
+        description: "Activate a license key to unlock premium features.",
         inputSchema: {
             type: "object",
             properties: {
-                bundleId: {
-                    type: "string",
-                    description: "App bundle identifier",
-                },
-                payload: {
-                    type: "object",
-                    description: "Push notification payload (APS format)",
-                },
-                udid: {
+                licenseKey: {
                     type: "string",
-                    description: "Simulator UDID. Leave empty for the booted simulator.",
+                    description: "Your license key from mobiledevmcp.dev",
                 },
             },
-            required: ["bundleId", "payload"],
+            required: ["licenseKey"],
         },
     },
-    {
-        name: "ios_set_location",
-        description: "[PRO] Set the simulated GPS location on an iOS Simulator.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                latitude: {
-                    type: "number",
-                    description: "Latitude coordinate",
-                },
-                longitude: {
-                    type: "number",
-                    description: "Longitude coordinate",
-                },
-                udid: {
-                    type: "string",
-                    description: "Simulator UDID. Leave empty for the booted simulator.",
-                },
-            },
-            required: ["latitude", "longitude"],
-        },
-    },
-    // === REACT DEVTOOLS TOOLS ===
-    {
-        name: "setup_react_devtools",
-        description: "[PRO] Set up React DevTools connection for debugging. Configures port forwarding and checks connectivity.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                port: {
-                    type: "number",
-                    description: "DevTools port (default: 8097)",
-                    default: 8097,
-                },
-                device: {
-                    type: "string",
-                    description: "Specific Android device ID (optional)",
-                },
-            },
-        },
-    },
-    {
-        name: "check_devtools_connection",
-        description: "[PRO] Check if React DevTools is connected and get connection status.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                port: {
-                    type: "number",
-                    description: "DevTools port (default: 8097)",
-                    default: 8097,
-                },
-            },
-        },
-    },
-    {
-        name: "get_react_component_tree",
-        description: "[PRO] Get the React component hierarchy from connected DevTools. Shows component names and structure.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                port: {
-                    type: "number",
-                    description: "DevTools port (default: 8097)",
-                    default: 8097,
-                },
-                depth: {
-                    type: "number",
-                    description: "Maximum depth to traverse (default: 5)",
-                    default: 5,
-                },
-            },
-        },
-    },
-    {
-        name: "inspect_react_component",
-        description: "[PRO] Inspect a specific React component by ID. Returns props, state, and hooks.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                componentId: {
-                    type: "number",
-                    description: "Component ID from the component tree",
-                },
-                port: {
-                    type: "number",
-                    description: "DevTools port (default: 8097)",
-                    default: 8097,
-                },
-            },
-            required: ["componentId"],
-        },
-    },
-    {
-        name: "search_react_components",
-        description: "[PRO] Search for React components by name or pattern.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "Component name or pattern to search for",
-                },
-                port: {
-                    type: "number",
-                    description: "DevTools port (default: 8097)",
-                    default: 8097,
-                },
-            },
-            required: ["query"],
-        },
-    },
-];
-// Combine core tools with license tools
-const tools = [...coreTools, ...licenseTools];
-// ============================================================================
-// TOOL IMPLEMENTATIONS
-// ============================================================================
-async function getMetroLogs(lines = 50, filter) {
-    // Check license/trial status
-    const check = await requireBasic("get_metro_logs");
-    if (!check.allowed)
-        return check.message;
-    const license = await checkLicense();
-    const tierLimits = TIER_LIMITS[license.tier];
-    const maxLines = Math.min(lines, tierLimits.maxLogLines);
-    let logs = metroLogBuffer.slice(-maxLines);
-    if (filter) {
-        logs = logs.filter((line) => line.toLowerCase().includes(filter.toLowerCase()));
-    }
-    if (logs.length === 0) {
-        try {
-            const response = await fetchMetroStatus(CONFIG.metroPort);
-            let result = `Metro is running but no logs captured yet.\nMetro status: ${response}\n\nTip: Use 'start_metro_logging' with a log file path, or pipe Metro output:\n  npx expo start 2>&1 | tee metro.log`;
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-        catch {
-            let result = `No Metro logs available. Metro may not be running.\n\nTo capture logs:\n1. Start Metro with output to file: npx expo start 2>&1 | tee metro.log\n2. Use start_metro_logging tool with logFile parameter`;
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-    }
-    const header = license.valid
-        ? `📋 Metro Logs (${logs.length} lines):`
-        : `📋 Metro Logs (${logs.length} lines, trial mode):`;
-    let result = `${header}\n${"─".repeat(50)}\n${logs.join("\n")}`;
-    if (check.message)
-        result += `\n\n${check.message}`;
-    return result;
-}
-async function getAdbLogs(lines = 50, filter = "ReactNativeJS", level = "I") {
-    // Check license/trial status
-    const check = await requireBasic("get_adb_logs");
-    if (!check.allowed)
-        return check.message;
-    const license = await checkLicense();
-    const tierLimits = TIER_LIMITS[license.tier];
-    const maxLines = Math.min(lines, tierLimits.maxLogLines);
-    try {
-        await execAsync("adb version");
-        let command;
-        if (filter === "*") {
-            command = `adb logcat -d -t ${maxLines} *:${level}`;
-        }
-        else {
-            command = `adb logcat -d -t ${maxLines} ${filter}:${level} *:S`;
-        }
-        const { stdout, stderr } = await execAsync(command);
-        if (stderr && !stdout) {
-            return `ADB Error: ${stderr}`;
-        }
-        let result = stdout || "No logs found matching the filter.";
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        if (error.message.includes("not recognized") || error.message.includes("not found")) {
-            return "ADB is not installed or not in PATH. Please install Android SDK Platform Tools.";
-        }
-        if (error.message.includes("no devices")) {
-            return "No Android devices/emulators connected. Start an emulator or connect a device.";
-        }
-        return `Error getting ADB logs: ${error.message}`;
-    }
-}
-async function screenshotEmulator(device) {
-    // Check license/trial status
-    const check = await requireBasic("screenshot_emulator");
-    if (!check.allowed) {
-        return { success: false, error: check.message };
-    }
-    try {
-        const deviceFlag = device ? `-s ${device}` : "";
-        const screenshotPath = path.join(CONFIG.screenshotDir, `screenshot_${Date.now()}.png`);
-        // Capture screenshot
-        await execAsync(`adb ${deviceFlag} exec-out screencap -p > "${screenshotPath}"`);
-        // Read and convert to base64
-        const imageBuffer = fs.readFileSync(screenshotPath);
-        const base64Data = imageBuffer.toString("base64");
-        // Clean up temp file
-        fs.unlinkSync(screenshotPath);
-        // Save to history for Advanced users
-        const license = await checkLicense();
-        if (license.valid && license.tier === "advanced") {
-            screenshotHistory.unshift({
-                timestamp: new Date().toISOString(),
-                data: base64Data,
-            });
-            if (screenshotHistory.length > MAX_SCREENSHOT_HISTORY) {
-                screenshotHistory = screenshotHistory.slice(0, MAX_SCREENSHOT_HISTORY);
-            }
-        }
-        return {
-            success: true,
-            data: base64Data,
-            mimeType: "image/png",
-            trialMessage: check.message,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Failed to capture screenshot: ${error.message}`,
-        };
-    }
-}
-async function listDevices() {
-    // Check license/trial status
-    const check = await requireBasic("list_devices");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const { stdout } = await execAsync("adb devices -l");
-        const lines = stdout.trim().split("\n");
-        if (lines.length <= 1) {
-            let result = `No devices connected.\n\nTo connect:\n- Start an Android emulator (Android Studio, Genymotion)\n- Or connect a physical device with USB debugging enabled`;
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-        let result = stdout;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error listing devices: ${error.message}`;
-    }
-}
-async function fetchMetroStatus(port) {
-    return new Promise((resolve, reject) => {
-        const req = http.get(`http://localhost:${port}/status`, (res) => {
-            let data = "";
-            res.on("data", (chunk) => (data += chunk));
-            res.on("end", () => resolve(data || "Metro is running"));
-        });
-        req.on("error", (err) => reject(err));
-        req.setTimeout(3000, () => {
-            req.destroy();
-            reject(new Error("Timeout"));
-        });
-    });
-}
-async function checkMetroStatus(port = 8081) {
-    // Check license/trial status
-    const check = await requireBasic("check_metro_status");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const status = await fetchMetroStatus(port);
-        let result = `✅ Metro is running on port ${port}\nStatus: ${status}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch {
-        let result = `❌ Metro does not appear to be running on port ${port}.\n\nTo start Metro:\n  npx expo start\n  # or\n  npx react-native start`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-}
-async function getAppInfo(packageName) {
-    // Check license/trial status
-    const check = await requireBasic("get_app_info");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const { stdout } = await execAsync(`adb shell dumpsys package ${packageName}`);
-        const lines = stdout.split("\n");
-        const relevantInfo = [];
-        for (const line of lines) {
-            if (line.includes("versionName") ||
-                line.includes("versionCode") ||
-                line.includes("targetSdk") ||
-                line.includes("dataDir") ||
-                line.includes("firstInstallTime") ||
-                line.includes("lastUpdateTime")) {
-                relevantInfo.push(line.trim());
-            }
-        }
-        if (relevantInfo.length === 0) {
-            let result = `Package ${packageName} not found on device.`;
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-        let result = `📱 App Info for ${packageName}:\n${relevantInfo.join("\n")}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error getting app info: ${error.message}`;
-    }
-}
-async function clearAppData(packageName) {
-    // Check license/trial status
-    const check = await requireBasic("clear_app_data");
-    if (!check.allowed)
-        return check.message;
-    try {
-        await execAsync(`adb shell pm clear ${packageName}`);
-        let result = `✅ Successfully cleared data for ${packageName}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error clearing app data: ${error.message}`;
-    }
-}
-async function restartAdb() {
-    // Check license/trial status
-    const check = await requireBasic("restart_adb");
-    if (!check.allowed)
-        return check.message;
-    try {
-        await execAsync("adb kill-server");
-        await execAsync("adb start-server");
-        const { stdout } = await execAsync("adb devices");
-        let result = `✅ ADB server restarted successfully.\n\nConnected devices:\n${stdout}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error restarting ADB: ${error.message}`;
-    }
-}
-async function getDeviceInfo(device) {
-    // Check license/trial status
-    const check = await requireBasic("get_device_info");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const deviceFlag = device ? `-s ${device}` : "";
-        const commands = [
-            `adb ${deviceFlag} shell getprop ro.build.version.release`,
-            `adb ${deviceFlag} shell getprop ro.build.version.sdk`,
-            `adb ${deviceFlag} shell getprop ro.product.model`,
-            `adb ${deviceFlag} shell getprop ro.product.manufacturer`,
-            `adb ${deviceFlag} shell wm size`,
-            `adb ${deviceFlag} shell wm density`,
-        ];
-        const results = await Promise.all(commands.map((cmd) => execAsync(cmd)
-            .then(({ stdout }) => stdout.trim())
-            .catch(() => "N/A")));
-        let result = `📱 Device Information:
-─────────────────────────────
-  Android Version: ${results[0]}
-  SDK Level: ${results[1]}
-  Model: ${results[3]} ${results[2]}
-  Screen Size: ${results[4].replace("Physical size: ", "")}
-  Screen Density: ${results[5].replace("Physical density: ", "")} dpi`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error getting device info: ${error.message}`;
-    }
-}
-// ============================================================================
-// FIXED: Metro Logging Implementation
-// ============================================================================
-async function startMetroLogging(logFile) {
-    // Check license/trial status
-    const check = await requireBasic("start_metro_logging");
-    if (!check.allowed)
-        return check.message;
-    if (metroProcess) {
-        let result = "Metro logging is already running. Use 'stop_metro_logging' first.";
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    metroLogBuffer = [];
-    // If a log file is provided, tail it
-    if (logFile) {
-        if (!fs.existsSync(logFile)) {
-            let result = `Log file not found: ${logFile}\n\nCreate it by running:\n  npx expo start 2>&1 | tee ${logFile}`;
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-        // Use PowerShell's Get-Content -Wait on Windows, tail -f on Unix
-        const isWindows = process.platform === "win32";
-        if (isWindows) {
-            metroProcess = spawn("powershell", [
-                "-Command",
-                `Get-Content -Path "${logFile}" -Wait -Tail 100`,
-            ]);
-        }
-        else {
-            metroProcess = spawn("tail", ["-f", "-n", "100", logFile]);
-        }
-        metroProcess.stdout?.on("data", (data) => {
-            const lines = data.toString().split("\n").filter((l) => l.trim());
-            metroLogBuffer.push(...lines);
-            if (metroLogBuffer.length > CONFIG.logBufferSize) {
-                metroLogBuffer = metroLogBuffer.slice(-CONFIG.logBufferSize);
-            }
-        });
-        metroProcess.stderr?.on("data", (data) => {
-            metroLogBuffer.push(`[STDERR] ${data.toString().trim()}`);
-        });
-        metroProcess.on("error", (err) => {
-            metroLogBuffer.push(`[ERROR] ${err.message}`);
-        });
-        let result = `✅ Metro log capture started!\nWatching: ${logFile}\n\nUse 'get_metro_logs' to retrieve captured logs.`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    // No log file provided - give instructions
-    let result = `📋 Metro Log Capture Setup
-─────────────────────────────
-
-To capture Metro logs, you have two options:
-
-Option 1: Pipe Metro to a file (Recommended)
-  npx expo start 2>&1 | tee metro.log
-
-  Then run: start_metro_logging with logFile="metro.log"
-
-Option 2: Check common log locations
-  - Expo: .expo/logs/
-  - React Native: Check Metro terminal output
-
-Option 3: Use ADB logs instead
-  For device-side JavaScript logs, use 'get_adb_logs'
-
-─────────────────────────────
-Once you have a log file, call this tool again with the logFile parameter.`;
-    if (check.message)
-        result += `\n\n${check.message}`;
-    return result;
-}
-async function stopMetroLogging() {
-    // Check license/trial status
-    const check = await requireBasic("stop_metro_logging");
-    if (!check.allowed)
-        return check.message;
-    if (metroProcess) {
-        metroProcess.kill();
-        metroProcess = null;
-    }
-    const logCount = metroLogBuffer.length;
-    let result = `✅ Metro logging stopped. ${logCount} log lines were captured.`;
-    if (check.message)
-        result += `\n\n${check.message}`;
-    return result;
-}
-// ============================================================================
-// PRO FEATURE IMPLEMENTATIONS
-// ============================================================================
-async function streamAdbRealtime(filter = "ReactNativeJS") {
-    const check = await requireAdvanced("stream_adb_realtime");
-    if (!check.allowed)
-        return check.message;
-    if (adbLogProcess) {
-        return "ADB streaming is already running. Use 'stop_adb_streaming' first.";
-    }
-    adbLogBuffer = [];
-    adbLogProcess = spawn("adb", ["logcat", `${filter}:V`, "*:S"]);
-    adbLogProcess.stdout?.on("data", (data) => {
-        const lines = data.toString().split("\n").filter((l) => l.trim());
-        adbLogBuffer.push(...lines);
-        if (adbLogBuffer.length > 500) {
-            adbLogBuffer = adbLogBuffer.slice(-500);
-        }
-    });
-    adbLogProcess.on("error", (err) => {
-        adbLogBuffer.push(`[ERROR] ${err.message}`);
-    });
-    return `✅ [PRO] Real-time ADB streaming started!\nFilter: ${filter}\n\nUse 'get_adb_logs' to retrieve the live buffer.`;
-}
-function stopAdbStreaming() {
-    if (adbLogProcess) {
-        adbLogProcess.kill();
-        adbLogProcess = null;
-    }
-    return `✅ ADB streaming stopped. Buffer contained ${adbLogBuffer.length} lines.`;
-}
-async function getScreenshotHistory(count = 5) {
-    const check = await requireAdvanced("screenshot_history");
-    if (!check.allowed)
-        return check.message;
-    if (screenshotHistory.length === 0) {
-        return "No screenshots in history. Take screenshots using 'screenshot_emulator' first.";
-    }
-    const recent = screenshotHistory.slice(0, count);
-    return `📸 [PRO] Screenshot History (${recent.length} of ${screenshotHistory.length}):\n\n${recent
-        .map((s, i) => `${i + 1}. ${s.timestamp}`)
-        .join("\n")}\n\nNote: Full image data available in tool response.`;
-}
-async function watchForErrors(patterns = ["Error", "Exception"], timeout = 60) {
-    const check = await requireAdvanced("watch_for_errors");
-    if (!check.allowed)
-        return check.message;
-    return new Promise((resolve) => {
-        const startTime = Date.now();
-        const checkInterval = setInterval(async () => {
-            // Check ADB logs for patterns
-            try {
-                const { stdout } = await execAsync("adb logcat -d -t 50 *:E");
-                for (const pattern of patterns) {
-                    if (stdout.toLowerCase().includes(pattern.toLowerCase())) {
-                        clearInterval(checkInterval);
-                        resolve(`🚨 [PRO] Error detected!\nPattern: "${pattern}"\n\nRelevant logs:\n${stdout}`);
-                        return;
-                    }
-                }
-            }
-            catch { }
-            // Check timeout
-            if (Date.now() - startTime > timeout * 1000) {
-                clearInterval(checkInterval);
-                resolve(`✅ [PRO] No errors detected in ${timeout} seconds.`);
-            }
-        }, 2000);
-    });
-}
-async function multiDeviceLogs(devices, lines = 30) {
-    const check = await requireAdvanced("multi_device_logs");
-    if (!check.allowed)
-        return check.message;
-    if (!devices || devices.length === 0) {
-        const { stdout } = await execAsync("adb devices");
-        return `No devices specified. Available devices:\n${stdout}`;
-    }
-    const results = await Promise.all(devices.map(async (device) => {
-        try {
-            const { stdout } = await execAsync(`adb -s ${device} logcat -d -t ${lines} ReactNativeJS:V *:S`);
-            return `📱 Device: ${device}\n${"─".repeat(30)}\n${stdout}`;
-        }
-        catch (error) {
-            return `📱 Device: ${device}\n${"─".repeat(30)}\nError: ${error.message}`;
-        }
-    }));
-    return `📋 [PRO] Multi-Device Logs\n${"═".repeat(50)}\n\n${results.join("\n\n")}`;
-}
-// ============================================================================
-// INTERACTION TOOLS (Advanced)
-// ============================================================================
-async function tapScreen(x, y, device) {
-    const check = await requireAdvanced("tap_screen");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const deviceFlag = device ? `-s ${device}` : "";
-        await execAsync(`adb ${deviceFlag} shell input tap ${x} ${y}`);
-        let result = `✅ Tapped at (${x}, ${y})`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error tapping screen: ${error.message}`;
-    }
-}
-async function inputText(text, device) {
-    const check = await requireAdvanced("input_text");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const deviceFlag = device ? `-s ${device}` : "";
-        // Escape special characters for shell
-        const escapedText = text.replace(/([\\'"$ `])/g, "\\$1").replace(/ /g, "%s");
-        await execAsync(`adb ${deviceFlag} shell input text "${escapedText}"`);
-        let result = `✅ Typed: "${text}"`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error inputting text: ${error.message}`;
-    }
-}
-async function pressButton(button, device) {
-    const check = await requireAdvanced("press_button");
-    if (!check.allowed)
-        return check.message;
-    const keyMap = {
-        back: 4,
-        home: 3,
-        recent: 187,
-        volume_up: 24,
-        volume_down: 25,
-        power: 26,
-        enter: 66,
-    };
-    const keyCode = keyMap[button];
-    if (!keyCode) {
-        return `Unknown button: ${button}. Available: ${Object.keys(keyMap).join(", ")}`;
-    }
-    try {
-        const deviceFlag = device ? `-s ${device}` : "";
-        await execAsync(`adb ${deviceFlag} shell input keyevent ${keyCode}`);
-        let result = `✅ Pressed: ${button.toUpperCase()}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error pressing button: ${error.message}`;
-    }
-}
-async function swipeScreen(startX, startY, endX, endY, duration = 300, device) {
-    const check = await requireAdvanced("swipe_screen");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const deviceFlag = device ? `-s ${device}` : "";
-        await execAsync(`adb ${deviceFlag} shell input swipe ${startX} ${startY} ${endX} ${endY} ${duration}`);
-        let result = `✅ Swiped from (${startX}, ${startY}) to (${endX}, ${endY})`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error swiping: ${error.message}`;
-    }
-}
-async function launchApp(packageName, device) {
-    const check = await requireAdvanced("launch_app");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const deviceFlag = device ? `-s ${device}` : "";
-        // Get the main activity using monkey
-        await execAsync(`adb ${deviceFlag} shell monkey -p ${packageName} -c android.intent.category.LAUNCHER 1`);
-        let result = `✅ Launched: ${packageName}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error launching app: ${error.message}\n\nMake sure the package name is correct.`;
-    }
-}
-async function installApk(apkPath, device) {
-    const check = await requireAdvanced("install_apk");
-    if (!check.allowed)
-        return check.message;
-    if (!fs.existsSync(apkPath)) {
-        return `APK file not found: ${apkPath}`;
-    }
-    try {
-        const deviceFlag = device ? `-s ${device}` : "";
-        const { stdout } = await execAsync(`adb ${deviceFlag} install -r "${apkPath}"`);
-        let result = `✅ APK installed successfully!\n\n${stdout}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error installing APK: ${error.message}`;
-    }
-}
-async function checkXcodeInstalled() {
-    try {
-        await execAsync("xcrun simctl help");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function listIosSimulators(onlyBooted = false) {
-    const check = await requireBasic("list_ios_simulators");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    try {
-        if (!(await checkXcodeInstalled())) {
-            return "Xcode Command Line Tools not installed. Run: xcode-select --install";
-        }
-        const { stdout } = await execAsync("xcrun simctl list devices -j");
-        const data = JSON.parse(stdout);
-        const results = [];
-        results.push("📱 iOS Simulators\n" + "═".repeat(50));
-        for (const [runtime, devices] of Object.entries(data.devices)) {
-            const deviceList = devices;
-            const filteredDevices = onlyBooted
-                ? deviceList.filter((d) => d.state === "Booted")
-                : deviceList.filter((d) => d.isAvailable);
-            if (filteredDevices.length > 0) {
-                // Extract iOS version from runtime identifier
-                const runtimeName = runtime.split(".").pop()?.replace(/-/g, " ") || runtime;
-                results.push(`\n${runtimeName}:`);
-                for (const device of filteredDevices) {
-                    const status = device.state === "Booted" ? "🟢 Booted" : "⚪ Shutdown";
-                    results.push(`  ${status} ${device.name}`);
-                    results.push(`      UDID: ${device.udid}`);
-                }
-            }
-        }
-        if (results.length === 1) {
-            let result = onlyBooted
-                ? "No booted simulators found. Boot one with 'boot_ios_simulator'."
-                : "No iOS Simulators available. Open Xcode to download simulator runtimes.";
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-        let result = results.join("\n");
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error listing iOS Simulators: ${error.message}`;
-    }
-}
-async function screenshotIosSimulator(udid) {
-    const check = await requireBasic("screenshot_ios_simulator");
-    if (!check.allowed) {
-        return { success: false, error: check.message };
-    }
-    if (process.platform !== "darwin") {
-        return { success: false, error: "iOS Simulators are only available on macOS." };
-    }
-    try {
-        const target = udid || "booted";
-        const screenshotPath = path.join(CONFIG.screenshotDir, `ios_screenshot_${Date.now()}.png`);
-        await execAsync(`xcrun simctl io ${target} screenshot "${screenshotPath}"`);
-        const imageBuffer = fs.readFileSync(screenshotPath);
-        const base64Data = imageBuffer.toString("base64");
-        fs.unlinkSync(screenshotPath);
-        // Save to history for Advanced users
-        const license = await checkLicense();
-        if (license.valid && license.tier === "advanced") {
-            screenshotHistory.unshift({
-                timestamp: new Date().toISOString(),
-                data: base64Data,
-            });
-            if (screenshotHistory.length > MAX_SCREENSHOT_HISTORY) {
-                screenshotHistory = screenshotHistory.slice(0, MAX_SCREENSHOT_HISTORY);
-            }
-        }
-        return {
-            success: true,
-            data: base64Data,
-            mimeType: "image/png",
-            trialMessage: check.message,
-        };
-    }
-    catch (error) {
-        if (error.message.includes("No devices are booted")) {
-            return { success: false, error: "No iOS Simulator is booted. Boot one first with 'boot_ios_simulator'." };
-        }
-        return { success: false, error: `Failed to capture iOS screenshot: ${error.message}` };
-    }
-}
-async function getIosSimulatorLogs(udid, filter, lines = 50) {
-    const check = await requireBasic("get_ios_simulator_logs");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    const license = await checkLicense();
-    const tierLimits = TIER_LIMITS[license.tier];
-    const maxLines = Math.min(lines, tierLimits.maxLogLines);
-    try {
-        const target = udid || "booted";
-        // Use predicate filter if provided
-        let command = `xcrun simctl spawn ${target} log show --last 5m --style compact`;
-        if (filter) {
-            command += ` --predicate 'eventMessage CONTAINS "${filter}" OR subsystem CONTAINS "${filter}"'`;
-        }
-        const { stdout, stderr } = await execAsync(command, { maxBuffer: 10 * 1024 * 1024 });
-        if (stderr && !stdout) {
-            return `Error: ${stderr}`;
-        }
-        const logLines = stdout.split("\n").slice(-maxLines);
-        let result = `📋 iOS Simulator Logs (${logLines.length} lines):\n${"─".repeat(50)}\n${logLines.join("\n")}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        if (error.message.includes("No devices are booted")) {
-            return "No iOS Simulator is booted. Boot one first with 'boot_ios_simulator'.";
-        }
-        return `Error getting iOS logs: ${error.message}`;
-    }
-}
-async function getIosSimulatorInfo(udid) {
-    const check = await requireBasic("get_ios_simulator_info");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    try {
-        const { stdout } = await execAsync("xcrun simctl list devices -j");
-        const data = JSON.parse(stdout);
-        // Find the target device
-        let targetDevice = null;
-        let targetRuntime = "";
-        for (const [runtime, devices] of Object.entries(data.devices)) {
-            const deviceList = devices;
-            const found = deviceList.find((d) => udid ? d.udid === udid : d.state === "Booted");
-            if (found) {
-                targetDevice = found;
-                targetRuntime = runtime;
-                break;
-            }
-        }
-        if (!targetDevice) {
-            return udid
-                ? `Simulator with UDID ${udid} not found.`
-                : "No booted simulator found. Boot one first or specify a UDID.";
-        }
-        const runtimeName = targetRuntime.split(".").pop()?.replace(/-/g, " ") || targetRuntime;
-        let result = `📱 iOS Simulator Info
-${"─".repeat(40)}
-  Name: ${targetDevice.name}
-  UDID: ${targetDevice.udid}
-  State: ${targetDevice.state === "Booted" ? "🟢 Booted" : "⚪ Shutdown"}
-  Runtime: ${runtimeName}
-  Available: ${targetDevice.isAvailable ? "Yes" : "No"}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error getting simulator info: ${error.message}`;
-    }
-}
-async function bootIosSimulator(udid) {
-    const check = await requireAdvanced("boot_ios_simulator");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    try {
-        await execAsync(`xcrun simctl boot "${udid}"`);
-        let result = `✅ iOS Simulator booted: ${udid}\n\nOpening Simulator app...`;
-        // Open Simulator app to show the booted device
-        try {
-            await execAsync("open -a Simulator");
-        }
-        catch { }
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        if (error.message.includes("Unable to boot device in current state: Booted")) {
-            return "Simulator is already booted.";
-        }
-        return `Error booting simulator: ${error.message}`;
-    }
-}
-async function shutdownIosSimulator(udid) {
-    const check = await requireAdvanced("shutdown_ios_simulator");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    try {
-        if (udid.toLowerCase() === "all") {
-            await execAsync("xcrun simctl shutdown all");
-            let result = "✅ All iOS Simulators have been shut down.";
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-        await execAsync(`xcrun simctl shutdown "${udid}"`);
-        let result = `✅ iOS Simulator shut down: ${udid}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        if (error.message.includes("Unable to shutdown device in current state: Shutdown")) {
-            return "Simulator is already shut down.";
-        }
-        return `Error shutting down simulator: ${error.message}`;
-    }
-}
-async function installIosApp(appPath, udid) {
-    const check = await requireAdvanced("install_ios_app");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    if (!fs.existsSync(appPath)) {
-        return `App not found: ${appPath}`;
-    }
-    try {
-        const target = udid || "booted";
-        await execAsync(`xcrun simctl install ${target} "${appPath}"`);
-        let result = `✅ App installed successfully on iOS Simulator!`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error installing app: ${error.message}`;
-    }
-}
-async function launchIosApp(bundleId, udid) {
-    const check = await requireAdvanced("launch_ios_app");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    try {
-        const target = udid || "booted";
-        await execAsync(`xcrun simctl launch ${target} "${bundleId}"`);
-        let result = `✅ Launched: ${bundleId}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error launching app: ${error.message}\n\nMake sure the bundle ID is correct and the app is installed.`;
-    }
-}
-async function terminateIosApp(bundleId, udid) {
-    const check = await requireAdvanced("terminate_ios_app");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    try {
-        const target = udid || "booted";
-        await execAsync(`xcrun simctl terminate ${target} "${bundleId}"`);
-        let result = `✅ Terminated: ${bundleId}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error terminating app: ${error.message}`;
-    }
-}
-async function iosOpenUrl(url, udid) {
-    const check = await requireAdvanced("ios_open_url");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    try {
-        const target = udid || "booted";
-        await execAsync(`xcrun simctl openurl ${target} "${url}"`);
-        let result = `✅ Opened URL: ${url}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error opening URL: ${error.message}`;
-    }
-}
-async function iosPushNotification(bundleId, payload, udid) {
-    const check = await requireAdvanced("ios_push_notification");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    try {
-        const target = udid || "booted";
-        const payloadPath = path.join(CONFIG.screenshotDir, `push_${Date.now()}.json`);
-        // Write payload to temp file
-        fs.writeFileSync(payloadPath, JSON.stringify(payload));
-        await execAsync(`xcrun simctl push ${target} "${bundleId}" "${payloadPath}"`);
-        // Clean up
-        fs.unlinkSync(payloadPath);
-        let result = `✅ Push notification sent to ${bundleId}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error sending push notification: ${error.message}`;
-    }
-}
-async function iosSetLocation(latitude, longitude, udid) {
-    const check = await requireAdvanced("ios_set_location");
-    if (!check.allowed)
-        return check.message;
-    if (process.platform !== "darwin") {
-        return "iOS Simulators are only available on macOS.";
-    }
-    try {
-        const target = udid || "booted";
-        await execAsync(`xcrun simctl location ${target} set ${latitude},${longitude}`);
-        let result = `✅ Location set to: ${latitude}, ${longitude}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        return `Error setting location: ${error.message}`;
-    }
-}
+];
 // ============================================================================
-// REACT DEVTOOLS INTEGRATION
+// TOOL IMPLEMENTATIONS
 // ============================================================================
-// Store for DevTools WebSocket connection
-let devToolsWs = null;
-let devToolsConnected = false;
-let componentTree = new Map();
-let pendingRequests = new Map();
-let requestId = 0;
-async function setupReactDevTools(port = 8097, device) {
-    const check = await requireAdvanced("setup_react_devtools");
-    if (!check.allowed)
-        return check.message;
-    const results = [];
-    results.push("🔧 React DevTools Setup\n" + "═".repeat(50));
-    // Step 1: Set up ADB port forwarding (for Android)
-    try {
-        const deviceFlag = device ? `-s ${device}` : "";
-        await execAsync(`adb ${deviceFlag} reverse tcp:${port} tcp:${port}`);
-        results.push(`\n✅ ADB port forwarding configured: tcp:${port} -> tcp:${port}`);
-    }
-    catch (error) {
-        results.push(`\n⚠️ ADB port forwarding failed: ${error.message}`);
-        results.push("   (This is OK if using iOS Simulator or DevTools is on same machine)");
-    }
-    // Step 2: Check if DevTools server is available
-    try {
-        const isRunning = await checkDevToolsServer(port);
-        if (isRunning) {
-            results.push(`✅ React DevTools server detected on port ${port}`);
-        }
-        else {
-            results.push(`⚠️ React DevTools server not detected on port ${port}`);
-            results.push("\nTo start React DevTools:");
-            results.push("  npx react-devtools");
-            results.push("  # or install globally:");
-            results.push("  npm install -g react-devtools && react-devtools");
-        }
-    }
-    catch (error) {
-        results.push(`⚠️ Could not check DevTools server: ${error.message}`);
+async function handleTool(name, args, tier) {
+    // Check tool access
+    if (!canAccessTool(name, tier)) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `This tool requires ADVANCED tier ($18/mo). Your tier: ${tier.toUpperCase()}. Upgrade at https://mobiledevmcp.dev/pricing`,
+                }],
+        };
     }
-    // Step 3: Connection instructions
-    results.push("\n📋 Next Steps:");
-    results.push("1. Make sure React DevTools standalone is running (npx react-devtools)");
-    results.push("2. Your React Native app should connect automatically in dev mode");
-    results.push("3. Use 'check_devtools_connection' to verify the connection");
-    results.push("4. Use 'get_react_component_tree' to inspect components");
-    let result = results.join("\n");
-    if (check.message)
-        result += `\n\n${check.message}`;
-    return result;
-}
-async function checkDevToolsServer(port) {
-    return new Promise((resolve) => {
-        const ws = new WebSocket(`ws://localhost:${port}`);
-        const timeout = setTimeout(() => {
-            ws.close();
-            resolve(false);
-        }, 3000);
-        ws.on("open", () => {
-            clearTimeout(timeout);
-            ws.close();
-            resolve(true);
-        });
-        ws.on("error", () => {
-            clearTimeout(timeout);
-            resolve(false);
-        });
-    });
-}
-async function checkDevToolsConnection(port = 8097) {
-    const check = await requireAdvanced("check_devtools_connection");
-    if (!check.allowed)
-        return check.message;
-    const results = [];
-    results.push("🔍 React DevTools Connection Status\n" + "═".repeat(50));
-    // Check if server is running
-    const serverRunning = await checkDevToolsServer(port);
-    if (!serverRunning) {
-        results.push(`\n❌ DevTools server not found on port ${port}`);
-        results.push("\nTo start React DevTools:");
-        results.push("  npx react-devtools");
-        let result = results.join("\n");
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
+    const device = args.device;
+    // Validate device ID if provided (security: prevent shell injection)
+    if (device && !validateDeviceId(device)) {
+        return {
+            content: [{ type: "text", text: "Invalid device ID format. Device IDs should be alphanumeric with dashes, colons, or periods." }],
+        };
     }
-    results.push(`\n✅ DevTools server running on port ${port}`);
-    // Try to connect and get basic info
-    try {
-        const connection = await connectToDevTools(port);
-        if (connection.connected) {
-            results.push("✅ Successfully connected to DevTools");
-            if (connection.rendererCount > 0) {
-                results.push(`✅ ${connection.rendererCount} React renderer(s) connected`);
-                results.push("\n📱 App is connected and ready for inspection!");
-                results.push("   Use 'get_react_component_tree' to view components");
+    const deviceArg = device ? `-s ${device}` : "";
+    switch (name) {
+        // === SCREENSHOTS ===
+        case "screenshot_emulator": {
+            try {
+                const base64 = await captureAndroidScreenshot(device);
+                return {
+                    content: [
+                        { type: "text", text: "Screenshot captured successfully" },
+                        { type: "image", data: base64, mimeType: "image/png" },
+                    ],
+                };
             }
-            else {
-                results.push("⚠️ No React renderers connected");
-                results.push("\nMake sure your React Native app is running in development mode.");
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to capture screenshot: ${error.message}` }] };
             }
         }
-        else {
-            results.push("⚠️ Connected to server but no app detected");
-        }
-    }
-    catch (error) {
-        results.push(`⚠️ Connection test failed: ${error.message}`);
-    }
-    let result = results.join("\n");
-    if (check.message)
-        result += `\n\n${check.message}`;
-    return result;
-}
-async function connectToDevTools(port) {
-    return new Promise((resolve, reject) => {
-        const ws = new WebSocket(`ws://localhost:${port}`);
-        let rendererCount = 0;
-        let resolved = false;
-        const timeout = setTimeout(() => {
-            if (!resolved) {
-                resolved = true;
-                ws.close();
-                resolve({ connected: true, rendererCount: 0 });
+        case "screenshot_ios_simulator": {
+            // Validate UDID if provided (defense in depth - also validated in captureIosScreenshot)
+            const iosUdid = args.udid;
+            if (iosUdid && !validateUdid(iosUdid)) {
+                return {
+                    content: [{ type: "text", text: "Invalid iOS Simulator UDID format. Must be UUID format or 'booted'." }],
+                };
             }
-        }, 5000);
-        ws.on("open", () => {
-            // DevTools protocol: request operations
-            // The standalone DevTools uses a different protocol than we might expect
-            // For now, we'll just confirm connection
-        });
-        ws.on("message", (data) => {
             try {
-                const message = JSON.parse(data.toString());
-                if (message.event === "operations" || message.event === "roots") {
-                    rendererCount++;
-                }
-            }
-            catch { }
-        });
-        ws.on("close", () => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                resolve({ connected: true, rendererCount });
-            }
-        });
-        ws.on("error", (err) => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                reject(err);
-            }
-        });
-        // Give it time to receive messages
-        setTimeout(() => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                ws.close();
-                resolve({ connected: true, rendererCount });
+                const base64 = await captureIosScreenshot(iosUdid);
+                return {
+                    content: [
+                        { type: "text", text: "iOS screenshot captured successfully" },
+                        { type: "image", data: base64, mimeType: "image/png" },
+                    ],
+                };
             }
-        }, 2000);
-    });
-}
-async function getReactComponentTree(port = 8097, depth = 5) {
-    const check = await requireAdvanced("get_react_component_tree");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const tree = await fetchComponentTree(port, depth);
-        if (!tree || tree.length === 0) {
-            let result = `📊 React Component Tree\n${"═".repeat(50)}\n\nNo components found.\n\nMake sure:\n1. React DevTools standalone is running (npx react-devtools)\n2. Your React Native app is running in development mode\n3. The app is connected to DevTools`;
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-        const lines = [];
-        lines.push("📊 React Component Tree");
-        lines.push("═".repeat(50));
-        lines.push("");
-        for (const node of tree) {
-            const indent = "  ".repeat(node.depth);
-            const typeIcon = node.type === "function" ? "ƒ" : node.type === "class" ? "◆" : "○";
-            lines.push(`${indent}${typeIcon} ${node.name} [id:${node.id}]`);
-            if (node.key) {
-                lines.push(`${indent}  key: "${node.key}"`);
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to capture iOS screenshot: ${error.message}` }] };
             }
         }
-        lines.push("");
-        lines.push(`Total: ${tree.length} components (depth: ${depth})`);
-        lines.push("\nUse 'inspect_react_component' with an [id] to see props/state");
-        let result = lines.join("\n");
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        let result = `Error fetching component tree: ${error.message}\n\nMake sure React DevTools is running: npx react-devtools`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-}
-async function fetchComponentTree(port, maxDepth) {
-    return new Promise((resolve, reject) => {
-        const ws = new WebSocket(`ws://localhost:${port}`);
-        const components = [];
-        let resolved = false;
-        const timeout = setTimeout(() => {
-            if (!resolved) {
-                resolved = true;
-                ws.close();
-                resolve(components);
-            }
-        }, 10000);
-        ws.on("open", () => {
-            // Send a request to get the tree
-            // The DevTools protocol varies, so we listen for operations
-        });
-        ws.on("message", (data) => {
+        // === DEVICE INFO ===
+        case "list_devices": {
             try {
-                const message = JSON.parse(data.toString());
-                // Handle different message types from React DevTools
-                if (message.event === "operations") {
-                    // Parse operations to build component tree
-                    const ops = message.payload;
-                    if (Array.isArray(ops)) {
-                        // Operations array contains component tree data
-                        parseOperations(ops, components, maxDepth);
-                    }
+                const devices = await listConnectedDevices();
+                const maxDevices = getMaxDevices(tier);
+                if (devices.length === 0) {
+                    return { content: [{ type: "text", text: "No devices connected. Start an emulator or connect a device." }] };
                 }
-                else if (message.event === "roots") {
-                    // Root components
-                    if (Array.isArray(message.payload)) {
-                        for (const root of message.payload) {
-                            components.push({
-                                id: root.id || components.length,
-                                name: root.displayName || root.name || "Root",
-                                type: root.type || "root",
-                                depth: 0,
-                            });
-                        }
-                    }
+                const limited = devices.slice(0, maxDevices);
+                let result = `Connected devices (showing ${limited.length}/${devices.length}):\n`;
+                result += limited.map((d) => `  ${d.id} - ${d.status}`).join("\n");
+                if (devices.length > maxDevices) {
+                    result += `\n\n[Upgrade to ADVANCED to see all ${devices.length} devices]`;
                 }
+                return { content: [{ type: "text", text: result }] };
             }
-            catch { }
-        });
-        ws.on("error", (err) => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                // Return empty array on error, not reject
-                resolve(components);
-            }
-        });
-        ws.on("close", () => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                resolve(components);
-            }
-        });
-        // Give time to receive data
-        setTimeout(() => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                ws.close();
-                resolve(components);
-            }
-        }, 3000);
-    });
-}
-function parseOperations(ops, components, maxDepth) {
-    // React DevTools operations format varies by version
-    // This is a simplified parser
-    let depth = 0;
-    for (let i = 0; i < ops.length && components.length < 100; i++) {
-        const op = ops[i];
-        if (typeof op === "object" && op.id !== undefined) {
-            if (depth <= maxDepth) {
-                components.push({
-                    id: op.id,
-                    name: op.displayName || op.name || `Component_${op.id}`,
-                    type: op.type === 1 ? "function" : op.type === 2 ? "class" : "other",
-                    depth: Math.min(op.depth || depth, maxDepth),
-                    key: op.key,
-                });
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to list devices: ${error.message}` }] };
             }
         }
-    }
-}
-async function inspectReactComponent(componentId, port = 8097) {
-    const check = await requireAdvanced("inspect_react_component");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const inspection = await fetchComponentDetails(componentId, port);
-        if (!inspection) {
-            let result = `Component with ID ${componentId} not found.\n\nUse 'get_react_component_tree' to get valid component IDs.`;
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-        const lines = [];
-        lines.push(`🔍 Component Inspection: ${inspection.name}`);
-        lines.push("═".repeat(50));
-        lines.push(`ID: ${componentId}`);
-        lines.push(`Type: ${inspection.type}`);
-        if (inspection.props && Object.keys(inspection.props).length > 0) {
-            lines.push("\n📦 Props:");
-            for (const [key, value] of Object.entries(inspection.props)) {
-                const displayValue = formatValue(value);
-                lines.push(`  ${key}: ${displayValue}`);
+        case "list_ios_simulators": {
+            if (process.platform !== "darwin") {
+                return { content: [{ type: "text", text: "iOS Simulators are only available on macOS" }] };
             }
-        }
-        else {
-            lines.push("\n📦 Props: (none)");
-        }
-        if (inspection.state && Object.keys(inspection.state).length > 0) {
-            lines.push("\n💾 State:");
-            for (const [key, value] of Object.entries(inspection.state)) {
-                const displayValue = formatValue(value);
-                lines.push(`  ${key}: ${displayValue}`);
+            try {
+                const { stdout } = await execAsync(`${XCRUN} simctl list devices --json`);
+                const data = JSON.parse(stdout);
+                const onlyBooted = args.onlyBooted;
+                let result = "iOS Simulators:\n";
+                for (const [runtime, devices] of Object.entries(data.devices)) {
+                    const filteredDevices = onlyBooted
+                        ? devices.filter((d) => d.state === "Booted")
+                        : devices;
+                    if (filteredDevices.length > 0) {
+                        result += `\n${runtime}:\n`;
+                        for (const device of filteredDevices) {
+                            result += `  ${device.name} (${device.udid}) - ${device.state}\n`;
+                        }
+                    }
+                }
+                return { content: [{ type: "text", text: result }] };
             }
-        }
-        if (inspection.hooks && inspection.hooks.length > 0) {
-            lines.push("\n🪝 Hooks:");
-            for (const hook of inspection.hooks) {
-                lines.push(`  ${hook.name}: ${formatValue(hook.value)}`);
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to list simulators: ${error.message}` }] };
             }
         }
-        let result = lines.join("\n");
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        let result = `Error inspecting component: ${error.message}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-}
-function formatValue(value) {
-    if (value === null)
-        return "null";
-    if (value === undefined)
-        return "undefined";
-    if (typeof value === "string")
-        return `"${value.substring(0, 100)}${value.length > 100 ? "..." : ""}"`;
-    if (typeof value === "number" || typeof value === "boolean")
-        return String(value);
-    if (Array.isArray(value))
-        return `Array(${value.length})`;
-    if (typeof value === "object") {
-        const keys = Object.keys(value);
-        if (keys.length === 0)
-            return "{}";
-        return `{${keys.slice(0, 3).join(", ")}${keys.length > 3 ? ", ..." : ""}}`;
-    }
-    if (typeof value === "function")
-        return "ƒ()";
-    return String(value).substring(0, 50);
-}
-async function fetchComponentDetails(componentId, port) {
-    return new Promise((resolve) => {
-        const ws = new WebSocket(`ws://localhost:${port}`);
-        let resolved = false;
-        let details = null;
-        const timeout = setTimeout(() => {
-            if (!resolved) {
-                resolved = true;
-                ws.close();
-                resolve(details);
-            }
-        }, 5000);
-        ws.on("open", () => {
-            // Request inspection of specific element
-            const request = {
-                event: "inspectElement",
-                payload: {
-                    id: componentId,
-                    rendererID: 1,
-                    requestID: Date.now(),
-                },
-            };
-            ws.send(JSON.stringify(request));
-        });
-        ws.on("message", (data) => {
+        case "get_device_info": {
             try {
-                const message = JSON.parse(data.toString());
-                if (message.event === "inspectedElement" && message.payload) {
-                    const p = message.payload;
-                    details = {
-                        name: p.displayName || p.name || `Component_${componentId}`,
-                        type: p.type || "unknown",
-                        props: p.props || {},
-                        state: p.state,
-                        hooks: p.hooks,
-                    };
+                const props = [
+                    "ro.product.model",
+                    "ro.build.version.release",
+                    "ro.build.version.sdk",
+                    "ro.product.manufacturer",
+                ];
+                let result = "Device Information:\n";
+                for (const prop of props) {
+                    const { stdout } = await execAsync(`${ADB} ${deviceArg} shell getprop ${prop}`);
+                    result += `  ${prop}: ${stdout.trim()}\n`;
                 }
+                // Screen size
+                const { stdout: screenSize } = await execAsync(`${ADB} ${deviceArg} shell wm size`);
+                result += `  Screen: ${screenSize.trim()}\n`;
+                // Memory (avoid shell piping - process in Node.js)
+                const { stdout: memInfo } = await execAsync(`${ADB} ${deviceArg} shell cat /proc/meminfo`);
+                const memLines = memInfo.split("\n").slice(0, 3); // Limit to first 3 lines in Node.js
+                result += `  Memory:\n${memLines.map((l) => `    ${l}`).join("\n")}`;
+                return { content: [{ type: "text", text: result }] };
             }
-            catch { }
-        });
-        ws.on("error", () => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                resolve(null);
-            }
-        });
-        ws.on("close", () => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                resolve(details);
-            }
-        });
-        // Give time to receive response
-        setTimeout(() => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                ws.close();
-                resolve(details);
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to get device info: ${error.message}` }] };
             }
-        }, 3000);
-    });
-}
-async function searchReactComponents(query, port = 8097) {
-    const check = await requireAdvanced("search_react_components");
-    if (!check.allowed)
-        return check.message;
-    try {
-        const tree = await fetchComponentTree(port, 10);
-        const queryLower = query.toLowerCase();
-        const matches = tree.filter((component) => component.name.toLowerCase().includes(queryLower));
-        if (matches.length === 0) {
-            let result = `🔍 Search Results for "${query}"\n${"═".repeat(50)}\n\nNo components found matching "${query}".\n\nTip: Try a partial name or check if the app is connected to DevTools.`;
-            if (check.message)
-                result += `\n\n${check.message}`;
-            return result;
-        }
-        const lines = [];
-        lines.push(`🔍 Search Results for "${query}"`);
-        lines.push("═".repeat(50));
-        lines.push(`\nFound ${matches.length} matching component(s):\n`);
-        for (const match of matches.slice(0, 20)) {
-            const typeIcon = match.type === "function" ? "ƒ" : match.type === "class" ? "◆" : "○";
-            lines.push(`${typeIcon} ${match.name} [id:${match.id}]`);
-        }
-        if (matches.length > 20) {
-            lines.push(`\n... and ${matches.length - 20} more matches`);
-        }
-        lines.push("\nUse 'inspect_react_component' with an [id] to see props/state");
-        let result = lines.join("\n");
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-    catch (error) {
-        let result = `Error searching components: ${error.message}`;
-        if (check.message)
-            result += `\n\n${check.message}`;
-        return result;
-    }
-}
-// ============================================================================
-// MCP SERVER SETUP
-// ============================================================================
-const server = new Server({
-    name: "claude-mobile-dev-mcp",
-    version: "0.1.0",
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-// Handle tool listing
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools,
-}));
-// Handle tool execution
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        // License tools
-        if (name === "get_license_status" || name === "set_license_key") {
-            const result = await handleLicenseTool(name, args || {});
-            return { content: [{ type: "text", text: result }] };
         }
-        // Core tools
-        switch (name) {
-            case "get_metro_logs": {
-                const result = await getMetroLogs(args?.lines, args?.filter);
-                return { content: [{ type: "text", text: result }] };
+        case "get_ios_simulator_info": {
+            if (process.platform !== "darwin") {
+                return { content: [{ type: "text", text: "iOS Simulators only available on macOS" }] };
             }
-            case "get_adb_logs": {
-                const result = await getAdbLogs(args?.lines, args?.filter, args?.level);
-                return { content: [{ type: "text", text: result }] };
+            // Validate UDID if provided
+            const simUdid = args.udid || "booted";
+            if (simUdid !== "booted" && !validateUdid(simUdid)) {
+                return {
+                    content: [{ type: "text", text: "Invalid iOS Simulator UDID format. Must be UUID format or 'booted'." }],
+                };
             }
-            case "screenshot_emulator": {
-                const result = await screenshotEmulator(args?.device);
-                if (result.success && result.data) {
-                    const content = [
-                        {
-                            type: "image",
-                            data: result.data,
-                            mimeType: result.mimeType,
-                        },
-                    ];
-                    // Add trial warning if present
-                    if (result.trialMessage) {
-                        content.push({ type: "text", text: result.trialMessage });
+            try {
+                const udid = simUdid;
+                const { stdout } = await execAsync(`${XCRUN} simctl list devices --json`);
+                const data = JSON.parse(stdout);
+                for (const devices of Object.values(data.devices)) {
+                    for (const device of devices) {
+                        if (device.udid === udid || (udid === "booted" && device.state === "Booted")) {
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: JSON.stringify(device, null, 2),
+                                    }],
+                            };
+                        }
                     }
-                    return { content };
                 }
-                return { content: [{ type: "text", text: result.error }] };
-            }
-            case "list_devices": {
-                const result = await listDevices();
-                return { content: [{ type: "text", text: result }] };
+                return { content: [{ type: "text", text: "Simulator not found" }] };
             }
-            case "check_metro_status": {
-                const result = await checkMetroStatus(args?.port);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to get simulator info: ${error.message}` }] };
             }
-            case "get_app_info": {
-                const result = await getAppInfo(args?.packageName);
-                return { content: [{ type: "text", text: result }] };
+        }
+        case "get_app_info": {
+            const packageName = args.packageName;
+            // Validate package name (security: prevent shell injection)
+            if (!validatePackageName(packageName)) {
+                return {
+                    content: [{ type: "text", text: "Invalid package name format. Package names should be like 'com.example.app'." }],
+                };
             }
-            case "clear_app_data": {
-                const result = await clearAppData(args?.packageName);
-                return { content: [{ type: "text", text: result }] };
+            try {
+                // Quote package name and avoid shell piping - process in Node.js
+                const { stdout } = await execAsync(`${ADB} ${deviceArg} shell dumpsys package "${packageName}"`);
+                const outputLines = stdout.split("\n").slice(0, 50).join("\n"); // Limit to 50 lines in Node.js
+                return { content: [{ type: "text", text: outputLines }] };
             }
-            case "restart_adb": {
-                const result = await restartAdb();
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to get app info: ${error.message}` }] };
             }
-            case "get_device_info": {
-                const result = await getDeviceInfo(args?.device);
+        }
+        // === LOGS ===
+        case "get_metro_logs": {
+            const requestedLines = args.lines || 50;
+            const maxLines = getMaxLogLines(tier);
+            // Ensure lines is a positive integer
+            const lines = Math.max(1, Math.min(Math.floor(requestedLines), maxLines));
+            try {
+                const port = CONFIG.metroPort;
+                const { stdout } = await execAsync(`curl -s http://localhost:${port}/status`, { timeout: 2000 });
+                let result = `Metro Status (port ${port}): ${stdout}\n`;
+                result += `\n[Metro logs require 'start_metro_logging' to capture output]`;
+                if (lines < requestedLines) {
+                    result += `\n[Showing ${lines} lines, upgrade to ADVANCED for more]`;
+                }
                 return { content: [{ type: "text", text: result }] };
             }
-            case "start_metro_logging": {
-                const result = await startMetroLogging(args?.logFile);
-                return { content: [{ type: "text", text: result }] };
+            catch {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Metro not responding on port ${CONFIG.metroPort}. Is it running?`,
+                        }],
+                };
             }
-            case "stop_metro_logging": {
-                const result = await stopMetroLogging();
-                return { content: [{ type: "text", text: result }] };
+        }
+        case "get_adb_logs": {
+            const requestedLines = args.lines || 50;
+            const maxLines = getMaxLogLines(tier);
+            // Ensure lines is a positive integer (security: prevent injection via negative/float values)
+            const lines = Math.max(1, Math.min(Math.floor(requestedLines), maxLines));
+            const filter = args.filter || "ReactNativeJS";
+            const level = args.level || "I";
+            // Validate filter (security: prevent shell injection)
+            if (!validateLogFilter(filter)) {
+                return {
+                    content: [{ type: "text", text: "Invalid log filter format. Filters should be alphanumeric with underscores (e.g., 'ReactNativeJS', '*')." }],
+                };
             }
-            // PRO FEATURES
-            case "stream_adb_realtime": {
-                const result = await streamAdbRealtime(args?.filter);
-                return { content: [{ type: "text", text: result }] };
+            // Validate level
+            if (!validateLogLevel(level)) {
+                return {
+                    content: [{ type: "text", text: "Invalid log level. Use one of: V, D, I, W, E, F." }],
+                };
             }
-            case "stop_adb_streaming": {
-                const result = stopAdbStreaming();
+            try {
+                const filterArg = filter === "*" ? "" : `-s ${filter}:${level}`;
+                const { stdout } = await execAsync(`${ADB} ${deviceArg} logcat -d ${filterArg} -t ${lines}`, { timeout: 5000 });
+                let result = stdout || "No logs found";
+                if (lines < requestedLines) {
+                    result += `\n\n[Showing ${lines} lines, upgrade to ADVANCED for more]`;
+                }
                 return { content: [{ type: "text", text: result }] };
             }
-            case "screenshot_history": {
-                const result = await getScreenshotHistory(args?.count);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to get logs: ${error.message}` }] };
             }
-            case "watch_for_errors": {
-                const result = await watchForErrors(args?.patterns, args?.timeout);
-                return { content: [{ type: "text", text: result }] };
+        }
+        case "get_ios_simulator_logs": {
+            if (process.platform !== "darwin") {
+                return { content: [{ type: "text", text: "iOS Simulator logs only available on macOS" }] };
             }
-            case "multi_device_logs": {
-                const result = await multiDeviceLogs(args?.devices, args?.lines);
-                return { content: [{ type: "text", text: result }] };
+            const requestedLines = args.lines || 50;
+            const maxLines = getMaxLogLines(tier);
+            // Ensure lines is a safe positive integer (security: prevent tail injection)
+            const lines = Math.max(1, Math.min(Math.floor(requestedLines), maxLines));
+            try {
+                // Avoid shell piping - process in Node.js
+                const { stdout } = await execAsync(`log show --predicate 'subsystem CONTAINS "com.apple.CoreSimulator"' --last 5m --style compact`, { timeout: 10000 });
+                // Limit output lines in Node.js instead of shell tail
+                const outputLines = stdout.split("\n").slice(-lines).join("\n");
+                return { content: [{ type: "text", text: outputLines || "No recent logs found" }] };
             }
-            // INTERACTION TOOLS
-            case "tap_screen": {
-                const result = await tapScreen(args?.x, args?.y, args?.device);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to get iOS logs: ${error.message}` }] };
             }
-            case "input_text": {
-                const result = await inputText(args?.text, args?.device);
-                return { content: [{ type: "text", text: result }] };
+        }
+        case "check_metro_status": {
+            const port = args.port || CONFIG.metroPort;
+            // Validate port (security: prevent injection via port number)
+            if (!Number.isInteger(port) || port < 1 || port > 65535) {
+                return {
+                    content: [{ type: "text", text: "Invalid port number. Port must be between 1 and 65535." }],
+                };
             }
-            case "press_button": {
-                const result = await pressButton(args?.button, args?.device);
-                return { content: [{ type: "text", text: result }] };
+            try {
+                const { stdout } = await execAsync(`curl -s http://localhost:${port}/status`, { timeout: 2000 });
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Metro bundler is running on port ${port}\nStatus: ${stdout}`,
+                        }],
+                };
             }
-            case "swipe_screen": {
-                const result = await swipeScreen(args?.startX, args?.startY, args?.endX, args?.endY, args?.duration, args?.device);
-                return { content: [{ type: "text", text: result }] };
+            catch {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Metro bundler is NOT running on port ${port}`,
+                        }],
+                };
             }
-            case "launch_app": {
-                const result = await launchApp(args?.packageName, args?.device);
-                return { content: [{ type: "text", text: result }] };
+        }
+        // === UI TREE (ADVANCED) ===
+        case "get_ui_tree": {
+            try {
+                const compressed = args.compressed !== false;
+                const { stdout } = await execAsync(`${ADB} ${deviceArg} exec-out uiautomator dump /dev/tty`, { timeout: 10000 });
+                const elements = parseUiTree(stdout);
+                const filtered = compressed
+                    ? elements.filter((el) => el.clickable || el.text || el.contentDescription)
+                    : elements;
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                elementCount: filtered.length,
+                                elements: filtered.map((el) => ({
+                                    text: el.text,
+                                    resourceId: el.resourceId,
+                                    className: el.className.split(".").pop(),
+                                    contentDescription: el.contentDescription,
+                                    bounds: el.bounds,
+                                    clickable: el.clickable,
+                                    center: el.centerX && el.centerY ? { x: el.centerX, y: el.centerY } : undefined,
+                                })),
+                            }, null, 2),
+                        }],
+                };
             }
-            case "install_apk": {
-                const result = await installApk(args?.apkPath, args?.device);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to get UI tree: ${error.message}` }] };
             }
-            // iOS SIMULATOR TOOLS
-            case "list_ios_simulators": {
-                const result = await listIosSimulators(args?.onlyBooted);
-                return { content: [{ type: "text", text: result }] };
+        }
+        case "find_element": {
+            // Validate search parameters have reasonable length (prevent DoS)
+            const MAX_SEARCH_LEN = 500;
+            const searchText = args.text;
+            const searchResourceId = args.resourceId;
+            const searchContentDesc = args.contentDescription;
+            if ((searchText && searchText.length > MAX_SEARCH_LEN) ||
+                (searchResourceId && searchResourceId.length > MAX_SEARCH_LEN) ||
+                (searchContentDesc && searchContentDesc.length > MAX_SEARCH_LEN)) {
+                return { content: [{ type: "text", text: "Search parameters too long (max 500 chars)" }] };
             }
-            case "screenshot_ios_simulator": {
-                const result = await screenshotIosSimulator(args?.udid);
-                if (result.success && result.data) {
-                    const content = [
-                        {
-                            type: "image",
-                            data: result.data,
-                            mimeType: result.mimeType,
-                        },
-                    ];
-                    if (result.trialMessage) {
-                        content.push({ type: "text", text: result.trialMessage });
+            try {
+                const { stdout } = await execAsync(`${ADB} ${deviceArg} exec-out uiautomator dump /dev/tty`, { timeout: 10000 });
+                const elements = parseUiTree(stdout);
+                const found = findElementInTree(elements, {
+                    text: searchText,
+                    resourceId: searchResourceId,
+                    contentDescription: searchContentDesc,
+                });
+                if (found) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    found: true,
+                                    element: {
+                                        text: found.text,
+                                        resourceId: found.resourceId,
+                                        className: found.className,
+                                        contentDescription: found.contentDescription,
+                                        bounds: found.bounds,
+                                        center: { x: found.centerX, y: found.centerY },
+                                        clickable: found.clickable,
+                                        enabled: found.enabled,
+                                    },
+                                }, null, 2),
+                            }],
+                    };
+                }
+                return { content: [{ type: "text", text: JSON.stringify({ found: false }) }] };
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to find element: ${error.message}` }] };
+            }
+        }
+        case "wait_for_element": {
+            // Cap timeout at 60 seconds to prevent indefinite blocking
+            const MAX_TIMEOUT = 60000;
+            const requestedTimeout = args.timeout || 5000;
+            const timeout = Math.max(1000, Math.min(requestedTimeout, MAX_TIMEOUT));
+            const pollInterval = 500;
+            const startTime = Date.now();
+            // Validate search parameters have reasonable length (prevent DoS)
+            const MAX_SEARCH_LEN = 500;
+            const searchText = args.text;
+            const searchResourceId = args.resourceId;
+            const searchContentDesc = args.contentDescription;
+            if ((searchText && searchText.length > MAX_SEARCH_LEN) ||
+                (searchResourceId && searchResourceId.length > MAX_SEARCH_LEN) ||
+                (searchContentDesc && searchContentDesc.length > MAX_SEARCH_LEN)) {
+                return { content: [{ type: "text", text: "Search parameters too long (max 500 chars)" }] };
+            }
+            while (Date.now() - startTime < timeout) {
+                try {
+                    const { stdout } = await execAsync(`${ADB} ${deviceArg} exec-out uiautomator dump /dev/tty`, { timeout: 5000 });
+                    const elements = parseUiTree(stdout);
+                    const found = findElementInTree(elements, {
+                        text: searchText,
+                        resourceId: searchResourceId,
+                        contentDescription: searchContentDesc,
+                    });
+                    if (found) {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        found: true,
+                                        waitTime: Date.now() - startTime,
+                                        element: {
+                                            text: found.text,
+                                            center: { x: found.centerX, y: found.centerY },
+                                        },
+                                    }, null, 2),
+                                }],
+                        };
                     }
-                    return { content };
                 }
-                return { content: [{ type: "text", text: result.error }] };
-            }
-            case "get_ios_simulator_logs": {
-                const result = await getIosSimulatorLogs(args?.udid, args?.filter, args?.lines);
-                return { content: [{ type: "text", text: result }] };
+                catch {
+                    // Ignore errors during polling
+                }
+                await sleep(pollInterval);
             }
-            case "get_ios_simulator_info": {
-                const result = await getIosSimulatorInfo(args?.udid);
-                return { content: [{ type: "text", text: result }] };
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ found: false, timeout: true, waitTime: timeout }),
+                    }],
+            };
+        }
+        case "get_element_property":
+        case "assert_element": {
+            try {
+                const { stdout } = await execAsync(`${ADB} ${deviceArg} exec-out uiautomator dump /dev/tty`, { timeout: 10000 });
+                const elements = parseUiTree(stdout);
+                const found = findElementInTree(elements, {
+                    text: args.text,
+                    resourceId: args.resourceId,
+                    contentDescription: args.contentDescription,
+                });
+                if (name === "get_element_property") {
+                    const property = args.property;
+                    if (found) {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: JSON.stringify({ [property]: found[property] }),
+                                }],
+                        };
+                    }
+                    return { content: [{ type: "text", text: JSON.stringify({ error: "Element not found" }) }] };
+                }
+                // assert_element
+                const shouldExist = args.shouldExist !== false;
+                const exists = !!found;
+                const passed = shouldExist === exists;
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                passed,
+                                exists,
+                                shouldExist,
+                                element: found ? { text: found.text, enabled: found.enabled } : null,
+                            }, null, 2),
+                        }],
+                };
             }
-            case "boot_ios_simulator": {
-                const result = await bootIosSimulator(args?.udid);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed: ${error.message}` }] };
             }
-            case "shutdown_ios_simulator": {
-                const result = await shutdownIosSimulator(args?.udid);
-                return { content: [{ type: "text", text: result }] };
+        }
+        // === SCREEN ANALYSIS (ADVANCED) ===
+        case "suggest_action": {
+            const goal = args.goal;
+            // Type guard and validation
+            if (!goal || typeof goal !== "string") {
+                return { content: [{ type: "text", text: "Goal parameter is required and must be a string" }] };
             }
-            case "install_ios_app": {
-                const result = await installIosApp(args?.appPath, args?.udid);
-                return { content: [{ type: "text", text: result }] };
+            // Validate goal has reasonable length (prevent DoS via long strings)
+            const MAX_GOAL_LEN = 1000;
+            if (goal.length > MAX_GOAL_LEN) {
+                return { content: [{ type: "text", text: `Goal too long (max ${MAX_GOAL_LEN} chars)` }] };
             }
-            case "launch_ios_app": {
-                const result = await launchIosApp(args?.bundleId, args?.udid);
-                return { content: [{ type: "text", text: result }] };
+            try {
+                const { stdout } = await execAsync(`${ADB} ${deviceArg} exec-out uiautomator dump /dev/tty`, { timeout: 10000 });
+                const elements = parseUiTree(stdout);
+                const clickableElements = elements.filter((el) => el.clickable && (el.text || el.contentDescription));
+                const suggestions = [];
+                const goalLower = goal.toLowerCase();
+                for (const el of clickableElements) {
+                    const text = (el.text || el.contentDescription || "").toLowerCase();
+                    if (goalLower.includes("login") && (text.includes("login") || text.includes("sign in"))) {
+                        suggestions.push({
+                            action: "tap",
+                            target: el.text || el.contentDescription,
+                            reasoning: "This button appears to initiate login",
+                        });
+                    }
+                    if (goalLower.includes("search") && (text.includes("search") || el.className.includes("EditText"))) {
+                        suggestions.push({
+                            action: el.className.includes("EditText") ? "input" : "tap",
+                            target: el.text || el.contentDescription || "search field",
+                            reasoning: "This appears to be a search input",
+                        });
+                    }
+                    if (goalLower.includes("settings") && text.includes("setting")) {
+                        suggestions.push({
+                            action: "tap",
+                            target: el.text || el.contentDescription,
+                            reasoning: "This navigates to settings",
+                        });
+                    }
+                    if (goalLower.includes("back") && text.includes("back")) {
+                        suggestions.push({
+                            action: "tap",
+                            target: el.text || el.contentDescription,
+                            reasoning: "This goes back",
+                        });
+                    }
+                }
+                if (suggestions.length === 0 && clickableElements.length > 0) {
+                    suggestions.push({
+                        action: "analyze",
+                        target: "screen",
+                        reasoning: `No direct match for "${goal}". ${clickableElements.length} clickable elements found. Use analyze_screen for details.`,
+                    });
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                goal,
+                                suggestions,
+                                clickableElementCount: clickableElements.length,
+                                note: "These are SUGGESTIONS only. MobileDevMCP is read-only and does not perform actions.",
+                            }, null, 2),
+                        }],
+                };
             }
-            case "terminate_ios_app": {
-                const result = await terminateIosApp(args?.bundleId, args?.udid);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to analyze screen: ${error.message}` }] };
             }
-            case "ios_open_url": {
-                const result = await iosOpenUrl(args?.url, args?.udid);
-                return { content: [{ type: "text", text: result }] };
+        }
+        case "analyze_screen": {
+            try {
+                const { stdout } = await execAsync(`${ADB} ${deviceArg} exec-out uiautomator dump /dev/tty`, { timeout: 10000 });
+                const elements = parseUiTree(stdout);
+                const analysis = {
+                    totalElements: elements.length,
+                    clickableElements: elements.filter((el) => el.clickable).length,
+                    textElements: elements.filter((el) => el.text).length,
+                    inputFields: elements.filter((el) => el.className.includes("EditText")).length,
+                    buttons: elements.filter((el) => el.className.includes("Button")).length,
+                    visibleText: elements
+                        .filter((el) => el.text)
+                        .map((el) => el.text)
+                        .slice(0, 20),
+                    interactiveElements: elements
+                        .filter((el) => el.clickable && (el.text || el.contentDescription))
+                        .map((el) => ({
+                        text: el.text || el.contentDescription,
+                        type: el.className.split(".").pop(),
+                        bounds: el.bounds,
+                    }))
+                        .slice(0, 15),
+                };
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(analysis, null, 2),
+                        }],
+                };
             }
-            case "ios_push_notification": {
-                const result = await iosPushNotification(args?.bundleId, args?.payload, args?.udid);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to analyze screen: ${error.message}` }] };
             }
-            case "ios_set_location": {
-                const result = await iosSetLocation(args?.latitude, args?.longitude, args?.udid);
-                return { content: [{ type: "text", text: result }] };
+        }
+        case "get_screen_text": {
+            try {
+                const { stdout } = await execAsync(`${ADB} ${deviceArg} exec-out uiautomator dump /dev/tty`, { timeout: 10000 });
+                const elements = parseUiTree(stdout);
+                const allText = elements
+                    .filter((el) => el.text || el.contentDescription)
+                    .map((el) => el.text || el.contentDescription)
+                    .filter((text, index, arr) => arr.indexOf(text) === index);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                textCount: allText.length,
+                                text: allText,
+                            }, null, 2),
+                        }],
+                };
             }
-            // REACT DEVTOOLS TOOLS
-            case "setup_react_devtools": {
-                const result = await setupReactDevTools(args?.port, args?.device);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to get screen text: ${error.message}` }] };
             }
-            case "check_devtools_connection": {
-                const result = await checkDevToolsConnection(args?.port);
-                return { content: [{ type: "text", text: result }] };
+        }
+        // === LICENSE ===
+        case "get_license_status": {
+            try {
+                const status = await getLicenseStatus();
+                return { content: [{ type: "text", text: status }] };
             }
-            case "get_react_component_tree": {
-                const result = await getReactComponentTree(args?.port, args?.depth);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to get license status: ${error.message}` }] };
             }
-            case "inspect_react_component": {
-                const result = await inspectReactComponent(args?.componentId, args?.port);
+        }
+        case "set_license_key": {
+            try {
+                const result = await setLicenseKey(args.licenseKey);
                 return { content: [{ type: "text", text: result }] };
             }
-            case "search_react_components": {
-                const result = await searchReactComponents(args?.query, args?.port);
-                return { content: [{ type: "text", text: result }] };
+            catch (error) {
+                return { content: [{ type: "text", text: `Failed to set license key: ${error.message}` }] };
             }
-            default:
-                return {
-                    content: [{ type: "text", text: `Unknown tool: ${name}` }],
-                    isError: true,
-                };
         }
+        default:
+            return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+    }
+}
+// ============================================================================
+// MCP SERVER SETUP
+// ============================================================================
+const server = new Server({
+    name: "mobile-dev-mcp",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const license = await checkLicense();
+    // Filter tools based on tier
+    const availableTools = tools.filter((tool) => canAccessTool(tool.name, license.tier));
+    return { tools: availableTools };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const license = await checkLicense();
+        const result = await handleTool(name, args || {}, license.tier);
+        return result;
     }
     catch (error) {
         return {
@@ -2303,14 +979,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
     }
 });
-// Start the server
+// Start server
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    // Log startup info to stderr (won't interfere with MCP protocol)
     const license = await checkLicense();
-    console.error(`Mobile Dev MCP Server v0.1.0`);
-    console.error(`License: ${license.tier.toUpperCase()}`);
+    console.error(`Mobile Dev MCP v1.0.0 - Read-Only Debugging`);
+    console.error(`License: ${license.tier.toUpperCase()} (${license.tier === "free" ? 8 : 21} tools)`);
     console.error(`Ready for connections...`);
 }
 main().catch((error) => {