@ggboi360/mobile-dev-mcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -682,6 +682,245 @@ const coreTools = [
             required: ["query"],
         },
     },
+    // === NETWORK INSPECTION TOOLS ===
+    {
+        name: "get_network_requests",
+        description: "[PRO] Get recent network requests from app logs. Parses fetch/XHR requests from React Native logs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                lines: {
+                    type: "number",
+                    description: "Number of log lines to search through (default: 200)",
+                    default: 200,
+                },
+                filter: {
+                    type: "string",
+                    description: "Filter by URL pattern or method (e.g., 'api', 'POST')",
+                },
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+            },
+        },
+    },
+    {
+        name: "start_network_monitoring",
+        description: "[PRO] Start real-time network request monitoring. Captures all HTTP/HTTPS traffic in background.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+            },
+        },
+    },
+    {
+        name: "stop_network_monitoring",
+        description: "[PRO] Stop network monitoring and get summary of captured requests.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "get_network_stats",
+        description: "[PRO] Get device network statistics including data usage, active connections, and WiFi info.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+            },
+        },
+    },
+    {
+        name: "analyze_request",
+        description: "[PRO] Analyze a specific network request by index from captured requests. Shows headers, body, timing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                index: {
+                    type: "number",
+                    description: "Request index from get_network_requests or monitoring",
+                },
+            },
+            required: ["index"],
+        },
+    },
+    // === EXPO DEVTOOLS INTEGRATION ===
+    {
+        name: "check_expo_status",
+        description: "[PRO] Check Expo dev server status. Shows bundler status, dev client connection, and tunnel URLs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                port: {
+                    type: "number",
+                    description: "Expo bundler port (default: 8081 for Expo SDK 49+, 19000 for older)",
+                    default: 8081,
+                },
+            },
+        },
+    },
+    {
+        name: "get_expo_config",
+        description: "[PRO] Get Expo project configuration from app.json or app.config.js. Shows app name, version, plugins, and more.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectPath: {
+                    type: "string",
+                    description: "Path to Expo project directory (default: current directory)",
+                },
+            },
+        },
+    },
+    {
+        name: "expo_dev_menu",
+        description: "[PRO] Open the Expo developer menu on the connected device. Equivalent to shaking the device or pressing 'd' in terminal.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+            },
+        },
+    },
+    {
+        name: "expo_reload",
+        description: "[PRO] Trigger a reload of the Expo app. Refreshes the JavaScript bundle without a full rebuild.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_eas_builds",
+        description: "[PRO] Get recent EAS (Expo Application Services) build status. Shows build history for your project.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                platform: {
+                    type: "string",
+                    enum: ["android", "ios", "all"],
+                    description: "Platform to show builds for (default: all)",
+                    default: "all",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of builds to show (default: 5)",
+                    default: 5,
+                },
+            },
+        },
+    },
+    // === PERFORMANCE METRICS TOOLS ===
+    {
+        name: "get_cpu_usage",
+        description: "[PRO] Get CPU usage for device or specific app. Shows per-core and per-process CPU consumption.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                packageName: {
+                    type: "string",
+                    description: "App package name to filter (optional, shows all if not specified)",
+                },
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_memory_usage",
+        description: "[PRO] Get memory usage for a specific app. Shows heap, native, graphics, and total memory consumption.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                packageName: {
+                    type: "string",
+                    description: "App package name (required)",
+                },
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+            },
+            required: ["packageName"],
+        },
+    },
+    {
+        name: "get_fps_stats",
+        description: "[PRO] Get frame rendering statistics (FPS). Shows jank frames, slow renders, and frame timing histogram.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                packageName: {
+                    type: "string",
+                    description: "App package name (required)",
+                },
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+                reset: {
+                    type: "boolean",
+                    description: "Reset stats before measuring (default: false)",
+                    default: false,
+                },
+            },
+            required: ["packageName"],
+        },
+    },
+    {
+        name: "get_battery_stats",
+        description: "[PRO] Get battery consumption statistics. Shows power usage by app and component.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                packageName: {
+                    type: "string",
+                    description: "App package name to filter (optional)",
+                },
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_performance_snapshot",
+        description: "[PRO] Get a comprehensive performance snapshot including CPU, memory, FPS, and battery stats for an app.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                packageName: {
+                    type: "string",
+                    description: "App package name (required)",
+                },
+                device: {
+                    type: "string",
+                    description: "Specific device ID (optional)",
+                },
+            },
+            required: ["packageName"],
+        },
+    },
 ];
 // Combine core tools with license tools
 const tools = [...coreTools, ...licenseTools];
@@ -2077,59 +2316,1112 @@ async function searchReactComponents(query, port = 8097) {
     }
 }
 // ============================================================================
-// MCP SERVER SETUP
+// NETWORK INSPECTION
 // ============================================================================
-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;
+// Network monitoring state
+let networkMonitorProcess = null;
+let networkRequestBuffer = [];
+const MAX_NETWORK_REQUESTS = 100;
+async function getNetworkRequests(lines = 200, filter, device) {
+    const check = await requireAdvanced("get_network_requests");
+    if (!check.allowed)
+        return check.message;
     try {
-        // License tools
-        if (name === "get_license_status" || name === "set_license_key") {
-            const result = await handleLicenseTool(name, args || {});
-            return { content: [{ type: "text", text: result }] };
+        const deviceFlag = device ? `-s ${device}` : "";
+        // Get logs and filter for network-related entries
+        // React Native logs network requests with various patterns
+        const { stdout } = await execAsync(`adb ${deviceFlag} logcat -d -t ${lines} *:V`, { maxBuffer: 5 * 1024 * 1024 });
+        const requests = [];
+        const logLines = stdout.split("\n");
+        // Patterns to match network requests
+        const patterns = [
+            // OkHttp pattern
+            /OkHttp.*?(GET|POST|PUT|DELETE|PATCH)\s+(.+)/i,
+            // React Native fetch pattern
+            /\[fetch\].*?(GET|POST|PUT|DELETE|PATCH)\s+(.+)/i,
+            // Generic HTTP pattern
+            /HTTP.*?(GET|POST|PUT|DELETE|PATCH)\s+(https?:\/\/\S+)/i,
+            // XMLHttpRequest pattern
+            /XMLHttpRequest.*?(GET|POST|PUT|DELETE|PATCH)\s+(.+)/i,
+            // Network response pattern
+            /(\d{3})\s+(https?:\/\/\S+).*?(\d+ms|\d+\.\d+s)/i,
+        ];
+        let index = 0;
+        for (const line of logLines) {
+            for (const pattern of patterns) {
+                const match = line.match(pattern);
+                if (match) {
+                    const method = match[1]?.toUpperCase() || "GET";
+                    const url = match[2] || "";
+                    // Apply filter if provided
+                    if (filter) {
+                        const filterLower = filter.toLowerCase();
+                        if (!method.toLowerCase().includes(filterLower) &&
+                            !url.toLowerCase().includes(filterLower)) {
+                            continue;
+                        }
+                    }
+                    requests.push({
+                        index: index++,
+                        timestamp: new Date().toISOString(),
+                        method,
+                        url: url.substring(0, 200),
+                        status: match[1]?.match(/^\d{3}$/) ? parseInt(match[1]) : undefined,
+                    });
+                    break;
+                }
+            }
         }
-        // Core tools
-        switch (name) {
-            case "get_metro_logs": {
-                const result = await getMetroLogs(args?.lines, args?.filter);
-                return { content: [{ type: "text", text: result }] };
+        if (requests.length === 0) {
+            let result = `📡 Network Requests\n${"═".repeat(50)}\n\nNo network requests found in recent logs.\n\nTips:\n- Make sure your app is making network requests\n- React Native logs network activity in development mode\n- Try increasing the lines parameter`;
+            if (check.message)
+                result += `\n\n${check.message}`;
+            return result;
+        }
+        const resultLines = [];
+        resultLines.push("📡 Network Requests");
+        resultLines.push("═".repeat(50));
+        resultLines.push(`\nFound ${requests.length} request(s):\n`);
+        for (const req of requests.slice(0, 30)) {
+            const statusIcon = req.status
+                ? (req.status >= 200 && req.status < 300 ? "✅" : "❌")
+                : "⏳";
+            resultLines.push(`[${req.index}] ${statusIcon} ${req.method} ${req.url.substring(0, 60)}${req.url.length > 60 ? "..." : ""}`);
+            if (req.status) {
+                resultLines.push(`    Status: ${req.status}`);
             }
-            case "get_adb_logs": {
-                const result = await getAdbLogs(args?.lines, args?.filter, args?.level);
-                return { content: [{ type: "text", text: result }] };
+        }
+        if (requests.length > 30) {
+            resultLines.push(`\n... and ${requests.length - 30} more requests`);
+        }
+        resultLines.push("\nUse 'start_network_monitoring' for real-time capture");
+        let result = resultLines.join("\n");
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    catch (error) {
+        return `Error getting network requests: ${error.message}`;
+    }
+}
+async function startNetworkMonitoring(device) {
+    const check = await requireAdvanced("start_network_monitoring");
+    if (!check.allowed)
+        return check.message;
+    if (networkMonitorProcess) {
+        return "Network monitoring is already running. Use 'stop_network_monitoring' first.";
+    }
+    networkRequestBuffer = [];
+    const deviceFlag = device ? `-s ${device}` : "";
+    // Start logcat with network-related filters
+    networkMonitorProcess = spawn("adb", [
+        ...deviceFlag.split(" ").filter(s => s),
+        "logcat",
+        "-v", "time",
+        "OkHttp:V",
+        "Retrofit:V",
+        "ReactNativeJS:V",
+        "*:S"
+    ]);
+    let requestIndex = 0;
+    networkMonitorProcess.stdout?.on("data", (data) => {
+        const lines = data.toString().split("\n");
+        for (const line of lines) {
+            // Parse network request patterns
+            const httpMatch = line.match(/(GET|POST|PUT|DELETE|PATCH)\s+(https?:\/\/\S+)/i);
+            if (httpMatch) {
+                networkRequestBuffer.push({
+                    index: requestIndex++,
+                    timestamp: new Date().toISOString(),
+                    method: httpMatch[1].toUpperCase(),
+                    url: httpMatch[2],
+                });
+                if (networkRequestBuffer.length > MAX_NETWORK_REQUESTS) {
+                    networkRequestBuffer = networkRequestBuffer.slice(-MAX_NETWORK_REQUESTS);
+                }
             }
-            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 });
-                    }
-                    return { content };
+            // Parse response status
+            const statusMatch = line.match(/<--\s*(\d{3})\s+(https?:\/\/\S+)/i);
+            if (statusMatch) {
+                const url = statusMatch[2];
+                const req = networkRequestBuffer.find(r => r.url === url && !r.status);
+                if (req) {
+                    req.status = parseInt(statusMatch[1]);
                 }
-                return { content: [{ type: "text", text: result.error }] };
             }
-            case "list_devices": {
-                const result = await listDevices();
+        }
+    });
+    networkMonitorProcess.on("error", (err) => {
+        console.error("Network monitor error:", err);
+    });
+    let result = `📡 Network Monitoring Started\n${"═".repeat(50)}\n\nCapturing HTTP/HTTPS requests in background.\n\nUse 'stop_network_monitoring' to stop and see captured requests.\nUse 'get_network_requests' to see current buffer.`;
+    if (check.message)
+        result += `\n\n${check.message}`;
+    return result;
+}
+async function stopNetworkMonitoring() {
+    const check = await requireAdvanced("stop_network_monitoring");
+    if (!check.allowed)
+        return check.message;
+    if (networkMonitorProcess) {
+        networkMonitorProcess.kill();
+        networkMonitorProcess = null;
+    }
+    const requests = networkRequestBuffer;
+    const summary = {
+        total: requests.length,
+        successful: requests.filter(r => r.status && r.status >= 200 && r.status < 300).length,
+        failed: requests.filter(r => r.status && (r.status < 200 || r.status >= 300)).length,
+        pending: requests.filter(r => !r.status).length,
+    };
+    const resultLines = [];
+    resultLines.push("📡 Network Monitoring Stopped");
+    resultLines.push("═".repeat(50));
+    resultLines.push(`\nSummary:`);
+    resultLines.push(`  Total requests: ${summary.total}`);
+    resultLines.push(`  Successful (2xx): ${summary.successful}`);
+    resultLines.push(`  Failed: ${summary.failed}`);
+    resultLines.push(`  Pending: ${summary.pending}`);
+    if (requests.length > 0) {
+        resultLines.push(`\nRecent requests:`);
+        for (const req of requests.slice(-10)) {
+            const statusIcon = req.status
+                ? (req.status >= 200 && req.status < 300 ? "✅" : "❌")
+                : "⏳";
+            resultLines.push(`[${req.index}] ${statusIcon} ${req.method} ${req.url.substring(0, 50)}...`);
+        }
+    }
+    let result = resultLines.join("\n");
+    if (check.message)
+        result += `\n\n${check.message}`;
+    return result;
+}
+async function getNetworkStats(device) {
+    const check = await requireAdvanced("get_network_stats");
+    if (!check.allowed)
+        return check.message;
+    try {
+        const deviceFlag = device ? `-s ${device}` : "";
+        // Get various network stats
+        const [wifiInfo, netStats, activeConns] = await Promise.all([
+            execAsync(`adb ${deviceFlag} shell dumpsys wifi | head -50`)
+                .then(r => r.stdout)
+                .catch(() => "N/A"),
+            execAsync(`adb ${deviceFlag} shell cat /proc/net/dev`)
+                .then(r => r.stdout)
+                .catch(() => "N/A"),
+            execAsync(`adb ${deviceFlag} shell netstat -an | head -30`)
+                .then(r => r.stdout)
+                .catch(() => "N/A"),
+        ]);
+        const resultLines = [];
+        resultLines.push("📊 Network Statistics");
+        resultLines.push("═".repeat(50));
+        // Parse WiFi info
+        const ssidMatch = wifiInfo.match(/mWifiInfo.*?SSID:\s*([^,]+)/);
+        const rssiMatch = wifiInfo.match(/RSSI:\s*(-?\d+)/);
+        const linkSpeedMatch = wifiInfo.match(/Link speed:\s*(\d+)/);
+        resultLines.push("\n📶 WiFi Info:");
+        if (ssidMatch)
+            resultLines.push(`  SSID: ${ssidMatch[1].trim()}`);
+        if (rssiMatch)
+            resultLines.push(`  Signal: ${rssiMatch[1]} dBm`);
+        if (linkSpeedMatch)
+            resultLines.push(`  Speed: ${linkSpeedMatch[1]} Mbps`);
+        // Parse network interface stats
+        resultLines.push("\n📈 Interface Stats:");
+        const devLines = netStats.split("\n").filter(l => l.includes("wlan") || l.includes("rmnet"));
+        for (const line of devLines.slice(0, 5)) {
+            const parts = line.trim().split(/\s+/);
+            if (parts.length >= 10) {
+                const iface = parts[0].replace(":", "");
+                const rxBytes = parseInt(parts[1]) || 0;
+                const txBytes = parseInt(parts[9]) || 0;
+                resultLines.push(`  ${iface}: RX ${formatBytes(rxBytes)}, TX ${formatBytes(txBytes)}`);
+            }
+        }
+        // Parse active connections
+        resultLines.push("\n🔗 Active Connections:");
+        const connLines = activeConns.split("\n")
+            .filter(l => l.includes("ESTABLISHED") || l.includes("TIME_WAIT"))
+            .slice(0, 8);
+        if (connLines.length > 0) {
+            for (const line of connLines) {
+                const parts = line.trim().split(/\s+/);
+                if (parts.length >= 5) {
+                    resultLines.push(`  ${parts[3]} -> ${parts[4]} (${parts[5] || ""})`);
+                }
+            }
+        }
+        else {
+            resultLines.push("  No active connections found");
+        }
+        let result = resultLines.join("\n");
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    catch (error) {
+        return `Error getting network stats: ${error.message}`;
+    }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+    return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;
+}
+async function analyzeRequest(index) {
+    const check = await requireAdvanced("analyze_request");
+    if (!check.allowed)
+        return check.message;
+    const request = networkRequestBuffer.find(r => r.index === index);
+    if (!request) {
+        let result = `Request #${index} not found.\n\nUse 'get_network_requests' or 'start_network_monitoring' to capture requests first.`;
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    const resultLines = [];
+    resultLines.push(`🔍 Request Analysis #${index}`);
+    resultLines.push("═".repeat(50));
+    resultLines.push(`\nMethod: ${request.method}`);
+    resultLines.push(`URL: ${request.url}`);
+    resultLines.push(`Timestamp: ${request.timestamp}`);
+    if (request.status) {
+        const statusText = request.status >= 200 && request.status < 300 ? "Success" : "Failed";
+        resultLines.push(`Status: ${request.status} (${statusText})`);
+    }
+    else {
+        resultLines.push("Status: Pending/Unknown");
+    }
+    if (request.duration) {
+        resultLines.push(`Duration: ${request.duration}ms`);
+    }
+    if (request.size) {
+        resultLines.push(`Size: ${request.size}`);
+    }
+    if (request.headers && Object.keys(request.headers).length > 0) {
+        resultLines.push("\n📋 Headers:");
+        for (const [key, value] of Object.entries(request.headers)) {
+            resultLines.push(`  ${key}: ${value}`);
+        }
+    }
+    if (request.body) {
+        resultLines.push("\n📤 Request Body:");
+        resultLines.push(`  ${request.body.substring(0, 500)}${request.body.length > 500 ? "..." : ""}`);
+    }
+    if (request.response) {
+        resultLines.push("\n📥 Response:");
+        resultLines.push(`  ${request.response.substring(0, 500)}${request.response.length > 500 ? "..." : ""}`);
+    }
+    let result = resultLines.join("\n");
+    if (check.message)
+        result += `\n\n${check.message}`;
+    return result;
+}
+// ============================================================================
+// EXPO DEVTOOLS INTEGRATION
+// ============================================================================
+async function checkExpoStatus(port = 8081) {
+    const check = await requireAdvanced("check_expo_status");
+    if (!check.allowed)
+        return check.message;
+    const resultLines = [];
+    resultLines.push("📱 Expo Dev Server Status");
+    resultLines.push("═".repeat(50));
+    // Check multiple ports that Expo might use
+    const portsToCheck = [
+        { port, name: "Metro Bundler" },
+        { port: 19000, name: "Legacy Bundler" },
+        { port: 19001, name: "WebSocket" },
+        { port: 19002, name: "DevTools UI" },
+    ];
+    let anyRunning = false;
+    for (const { port: p, name } of portsToCheck) {
+        try {
+            const response = await new Promise((resolve, reject) => {
+                const req = http.request({ hostname: "localhost", port: p, path: "/status", method: "GET", timeout: 2000 }, (res) => {
+                    let data = "";
+                    res.on("data", (chunk) => (data += chunk));
+                    res.on("end", () => resolve(data));
+                });
+                req.on("error", reject);
+                req.on("timeout", () => reject(new Error("timeout")));
+                req.end();
+            });
+            resultLines.push(`\n✅ ${name} (port ${p}): Running`);
+            if (response && response.length > 0 && response.length < 200) {
+                resultLines.push(`   Status: ${response.trim()}`);
+            }
+            anyRunning = true;
+        }
+        catch {
+            // Port not responding, check if it's a different status endpoint
+            try {
+                // Try the root endpoint for bundler status
+                const response = await new Promise((resolve, reject) => {
+                    const req = http.request({ hostname: "localhost", port: p, path: "/", method: "GET", timeout: 1000 }, (res) => {
+                        let data = "";
+                        res.on("data", (chunk) => (data += chunk));
+                        res.on("end", () => resolve(`HTTP ${res.statusCode}`));
+                    });
+                    req.on("error", reject);
+                    req.on("timeout", () => reject(new Error("timeout")));
+                    req.end();
+                });
+                resultLines.push(`\n✅ ${name} (port ${p}): Running (${response})`);
+                anyRunning = true;
+            }
+            catch {
+                resultLines.push(`\n⚪ ${name} (port ${p}): Not running`);
+            }
+        }
+    }
+    // Get Expo CLI version if available
+    try {
+        const { stdout: expoVersion } = await execAsync("npx expo --version", { timeout: 5000 });
+        resultLines.push(`\n📦 Expo CLI: v${expoVersion.trim()}`);
+    }
+    catch {
+        resultLines.push("\n📦 Expo CLI: Not detected");
+    }
+    // Check if any device is connected
+    try {
+        const { stdout: devices } = await execAsync("adb devices");
+        const deviceLines = devices.split("\n").filter(line => line.includes("\tdevice"));
+        if (deviceLines.length > 0) {
+            resultLines.push(`\n📱 Connected devices: ${deviceLines.length}`);
+        }
+    }
+    catch {
+        // ADB not available
+    }
+    if (!anyRunning) {
+        resultLines.push("\n⚠️  No Expo dev server detected. Start with:");
+        resultLines.push("   npx expo start");
+    }
+    let result = resultLines.join("\n");
+    if (check.message)
+        result += `\n\n${check.message}`;
+    return result;
+}
+async function getExpoConfig(projectPath) {
+    const check = await requireAdvanced("get_expo_config");
+    if (!check.allowed)
+        return check.message;
+    const cwd = projectPath || process.cwd();
+    const resultLines = [];
+    resultLines.push("📋 Expo Project Configuration");
+    resultLines.push("═".repeat(50));
+    // Try to read app.json
+    const appJsonPath = path.join(cwd, "app.json");
+    const appConfigJsPath = path.join(cwd, "app.config.js");
+    const appConfigTsPath = path.join(cwd, "app.config.ts");
+    let config = null;
+    if (fs.existsSync(appJsonPath)) {
+        try {
+            const content = fs.readFileSync(appJsonPath, "utf-8");
+            config = JSON.parse(content);
+            resultLines.push(`\nSource: app.json`);
+        }
+        catch (err) {
+            resultLines.push(`\n❌ Error reading app.json: ${err}`);
+        }
+    }
+    else if (fs.existsSync(appConfigJsPath)) {
+        resultLines.push(`\nSource: app.config.js (dynamic config)`);
+        // Can't easily evaluate JS config, suggest using expo config
+        try {
+            const { stdout } = await execAsync("npx expo config --json", { cwd, timeout: 10000 });
+            config = JSON.parse(stdout);
+        }
+        catch {
+            resultLines.push("⚠️  Run 'npx expo config' to see resolved config");
+        }
+    }
+    else if (fs.existsSync(appConfigTsPath)) {
+        resultLines.push(`\nSource: app.config.ts (TypeScript config)`);
+        try {
+            const { stdout } = await execAsync("npx expo config --json", { cwd, timeout: 10000 });
+            config = JSON.parse(stdout);
+        }
+        catch {
+            resultLines.push("⚠️  Run 'npx expo config' to see resolved config");
+        }
+    }
+    else {
+        resultLines.push(`\n❌ No Expo config found in: ${cwd}`);
+        resultLines.push("\nLooking for: app.json, app.config.js, or app.config.ts");
+        let result = resultLines.join("\n");
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    if (config) {
+        const expo = config.expo || config;
+        resultLines.push(`\n📱 App Name: ${expo.name || "N/A"}`);
+        resultLines.push(`📌 Slug: ${expo.slug || "N/A"}`);
+        resultLines.push(`📦 Version: ${expo.version || "N/A"}`);
+        resultLines.push(`🔧 SDK Version: ${expo.sdkVersion || "N/A"}`);
+        if (expo.ios) {
+            resultLines.push(`\n🍎 iOS:`);
+            resultLines.push(`   Bundle ID: ${expo.ios.bundleIdentifier || "N/A"}`);
+            if (expo.ios.buildNumber)
+                resultLines.push(`   Build: ${expo.ios.buildNumber}`);
+        }
+        if (expo.android) {
+            resultLines.push(`\n🤖 Android:`);
+            resultLines.push(`   Package: ${expo.android.package || "N/A"}`);
+            if (expo.android.versionCode)
+                resultLines.push(`   Version Code: ${expo.android.versionCode}`);
+        }
+        if (expo.plugins && expo.plugins.length > 0) {
+            resultLines.push(`\n🔌 Plugins (${expo.plugins.length}):`);
+            for (const plugin of expo.plugins.slice(0, 10)) {
+                const pluginName = Array.isArray(plugin) ? plugin[0] : plugin;
+                resultLines.push(`   - ${pluginName}`);
+            }
+            if (expo.plugins.length > 10) {
+                resultLines.push(`   ... and ${expo.plugins.length - 10} more`);
+            }
+        }
+        if (expo.extra) {
+            resultLines.push(`\n📎 Extra Config: ${JSON.stringify(expo.extra).substring(0, 100)}...`);
+        }
+    }
+    let result = resultLines.join("\n");
+    if (check.message)
+        result += `\n\n${check.message}`;
+    return result;
+}
+async function expoDevMenu(device) {
+    const check = await requireAdvanced("expo_dev_menu");
+    if (!check.allowed)
+        return check.message;
+    const deviceFlag = device ? `-s ${device}` : "";
+    try {
+        // The developer menu in React Native/Expo is triggered by shaking the device
+        // We can simulate this with a combination of keyboard events or the menu keycode
+        // KEYCODE_MENU = 82 opens the dev menu on most RN/Expo apps
+        await execAsync(`adb ${deviceFlag} shell input keyevent 82`);
+        let result = `✅ Developer menu triggered
+
+The Expo/React Native developer menu should now be visible.
+
+Available options typically include:
+- Reload
+- Go to Expo Home
+- Toggle Inspector
+- Toggle Performance Monitor
+- Show Element Inspector
+- Open JS Debugger
+- Fast Refresh settings`;
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    catch (error) {
+        let result = `Error opening dev menu: ${error.message}\n\nMake sure a device is connected: adb devices`;
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+}
+async function expoReload(device) {
+    const check = await requireAdvanced("expo_reload");
+    if (!check.allowed)
+        return check.message;
+    const deviceFlag = device ? `-s ${device}` : "";
+    try {
+        // Method 1: Send reload broadcast to Expo/RN
+        // Double-tap R in dev menu typically reloads
+        // KEYCODE_R = 46, but we need to simulate the reload command
+        // First try to use the reload command via adb
+        // Many Expo apps respond to the "RR" double-tap
+        await execAsync(`adb ${deviceFlag} shell input keyevent 82`); // Open menu
+        await new Promise(resolve => setTimeout(resolve, 300)); // Wait for menu
+        await execAsync(`adb ${deviceFlag} shell input text r`); // Press 'r' to reload
+        // Alternative: Send the reload intent directly if app supports it
+        try {
+            // Try sending a reload broadcast (works on some Expo setups)
+            await execAsync(`adb ${deviceFlag} shell am broadcast -a "com.facebook.react.reload"`);
+        }
+        catch {
+            // Not all apps support this broadcast
+        }
+        let result = `🔄 Reload triggered!
+
+The app should now be reloading its JavaScript bundle.
+
+If the app didn't reload, try:
+1. Press 'r' twice quickly in the Metro terminal
+2. Use expo_dev_menu and select "Reload"
+3. Shake the device to open dev menu`;
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    catch (error) {
+        let result = `Error triggering reload: ${error.message}\n\nMake sure a device is connected: adb devices`;
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+}
+async function getEasBuilds(platform = "all", limit = 5) {
+    const check = await requireAdvanced("get_eas_builds");
+    if (!check.allowed)
+        return check.message;
+    const resultLines = [];
+    resultLines.push("🏗️  EAS Build Status");
+    resultLines.push("═".repeat(50));
+    try {
+        // Check if eas-cli is available
+        await execAsync("npx eas-cli --version", { timeout: 5000 });
+        // Get build list
+        const platformFlag = platform !== "all" ? `--platform ${platform}` : "";
+        const { stdout } = await execAsync(`npx eas-cli build:list ${platformFlag} --limit ${limit} --json --non-interactive`, { timeout: 30000 });
+        let builds = [];
+        try {
+            builds = JSON.parse(stdout);
+        }
+        catch {
+            // Sometimes eas-cli outputs extra text before JSON
+            const jsonMatch = stdout.match(/\[[\s\S]*\]/);
+            if (jsonMatch) {
+                builds = JSON.parse(jsonMatch[0]);
+            }
+        }
+        if (builds.length === 0) {
+            resultLines.push("\nNo builds found.");
+            resultLines.push("\nTo create a build:");
+            resultLines.push("  npx eas-cli build --platform android");
+            resultLines.push("  npx eas-cli build --platform ios");
+        }
+        else {
+            resultLines.push(`\nShowing ${builds.length} most recent builds:\n`);
+            for (const build of builds) {
+                const platformEmoji = build.platform === "ANDROID" ? "🤖" : "🍎";
+                const statusEmoji = build.status === "FINISHED" ? "✅" :
+                    build.status === "IN_PROGRESS" ? "🔄" :
+                        build.status === "ERRORED" ? "❌" : "⏳";
+                resultLines.push(`${statusEmoji} ${platformEmoji} ${build.platform}`);
+                resultLines.push(`   Build ID: ${build.id}`);
+                resultLines.push(`   Status: ${build.status}`);
+                resultLines.push(`   Profile: ${build.buildProfile || "N/A"}`);
+                resultLines.push(`   Started: ${new Date(build.createdAt).toLocaleString()}`);
+                if (build.status === "FINISHED" && build.artifacts?.buildUrl) {
+                    resultLines.push(`   📥 Download: ${build.artifacts.buildUrl}`);
+                }
+                if (build.error) {
+                    resultLines.push(`   ❌ Error: ${build.error.message || build.error}`);
+                }
+                resultLines.push("");
+            }
+        }
+    }
+    catch (error) {
+        if (error.message?.includes("not found") || error.message?.includes("ENOENT")) {
+            resultLines.push("\n❌ EAS CLI not found");
+            resultLines.push("\nInstall with: npm install -g eas-cli");
+            resultLines.push("Then login: npx eas-cli login");
+        }
+        else if (error.message?.includes("not logged in") || error.message?.includes("AUTH")) {
+            resultLines.push("\n❌ Not logged in to EAS");
+            resultLines.push("\nLogin with: npx eas-cli login");
+        }
+        else {
+            resultLines.push(`\n❌ Error: ${error.message}`);
+            resultLines.push("\nMake sure you're in an Expo project directory with eas.json");
+        }
+    }
+    let result = resultLines.join("\n");
+    if (check.message)
+        result += `\n\n${check.message}`;
+    return result;
+}
+// ============================================================================
+// PERFORMANCE METRICS
+// ============================================================================
+async function getCpuUsage(packageName, device) {
+    const check = await requireAdvanced("get_cpu_usage");
+    if (!check.allowed)
+        return check.message;
+    const deviceFlag = device ? `-s ${device}` : "";
+    try {
+        const resultLines = [];
+        resultLines.push("📊 CPU Usage");
+        resultLines.push("═".repeat(50));
+        // Get overall CPU info
+        const { stdout: cpuInfo } = await execAsync(`adb ${deviceFlag} shell dumpsys cpuinfo`, { maxBuffer: 2 * 1024 * 1024 });
+        // Parse CPU usage
+        const lines = cpuInfo.split("\n");
+        const totalMatch = lines.find(line => line.includes("TOTAL"));
+        if (totalMatch) {
+            resultLines.push(`\n${totalMatch.trim()}`);
+        }
+        // If package specified, filter for that app
+        if (packageName) {
+            resultLines.push(`\n📱 App: ${packageName}`);
+            const appLines = lines.filter(line => line.toLowerCase().includes(packageName.toLowerCase()));
+            if (appLines.length > 0) {
+                appLines.forEach(line => {
+                    resultLines.push(`  ${line.trim()}`);
+                });
+            }
+            else {
+                resultLines.push("  App not found in CPU stats (may not be running)");
+            }
+        }
+        else {
+            // Show top processes
+            resultLines.push("\n🔝 Top Processes:");
+            const processLines = lines
+                .filter(line => line.includes("%") && !line.includes("TOTAL"))
+                .slice(0, 10);
+            processLines.forEach(line => {
+                resultLines.push(`  ${line.trim()}`);
+            });
+        }
+        // Get per-core usage
+        try {
+            const { stdout: coreInfo } = await execAsync(`adb ${deviceFlag} shell cat /proc/stat`, { timeout: 5000 });
+            const coreLines = coreInfo.split("\n").filter(line => line.startsWith("cpu"));
+            if (coreLines.length > 1) {
+                resultLines.push(`\n💻 CPU Cores: ${coreLines.length - 1}`);
+            }
+        }
+        catch {
+            // Core info not available
+        }
+        let result = resultLines.join("\n");
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    catch (error) {
+        let result = `Error getting CPU usage: ${error.message}`;
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+}
+async function getMemoryUsage(packageName, device) {
+    const check = await requireAdvanced("get_memory_usage");
+    if (!check.allowed)
+        return check.message;
+    const deviceFlag = device ? `-s ${device}` : "";
+    try {
+        const resultLines = [];
+        resultLines.push("🧠 Memory Usage");
+        resultLines.push("═".repeat(50));
+        resultLines.push(`\n📱 App: ${packageName}\n`);
+        // Get detailed memory info for the app
+        const { stdout: memInfo } = await execAsync(`adb ${deviceFlag} shell dumpsys meminfo ${packageName}`, { maxBuffer: 2 * 1024 * 1024 });
+        // Parse key memory metrics
+        const lines = memInfo.split("\n");
+        // Find summary section
+        const summaryStart = lines.findIndex(line => line.includes("App Summary"));
+        if (summaryStart !== -1) {
+            resultLines.push("📋 App Summary:");
+            for (let i = summaryStart + 1; i < Math.min(summaryStart + 10, lines.length); i++) {
+                const line = lines[i].trim();
+                if (line && !line.startsWith("--")) {
+                    resultLines.push(`  ${line}`);
+                }
+                if (line.includes("TOTAL"))
+                    break;
+            }
+        }
+        // Find PSS and heap info
+        const pssMatch = memInfo.match(/TOTAL PSS:\s+(\d+)/i) || memInfo.match(/TOTAL:\s+(\d+)/);
+        const heapMatch = memInfo.match(/Native Heap:\s+(\d+)/);
+        const javaHeapMatch = memInfo.match(/Java Heap:\s+(\d+)/);
+        if (pssMatch || heapMatch) {
+            resultLines.push("\n📊 Key Metrics:");
+            if (pssMatch) {
+                const pssKb = parseInt(pssMatch[1]);
+                resultLines.push(`  Total PSS: ${(pssKb / 1024).toFixed(1)} MB`);
+            }
+            if (javaHeapMatch) {
+                const heapKb = parseInt(javaHeapMatch[1]);
+                resultLines.push(`  Java Heap: ${(heapKb / 1024).toFixed(1)} MB`);
+            }
+            if (heapMatch) {
+                const nativeKb = parseInt(heapMatch[1]);
+                resultLines.push(`  Native Heap: ${(nativeKb / 1024).toFixed(1)} MB`);
+            }
+        }
+        // Memory warnings
+        if (memInfo.includes("Low memory")) {
+            resultLines.push("\n⚠️  Warning: Device is in low memory state");
+        }
+        let result = resultLines.join("\n");
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    catch (error) {
+        if (error.message?.includes("No process found")) {
+            let result = `App '${packageName}' is not running.\n\nStart the app first, then check memory usage.`;
+            if (check.message)
+                result += `\n\n${check.message}`;
+            return result;
+        }
+        let result = `Error getting memory usage: ${error.message}`;
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+}
+async function getFpsStats(packageName, device, reset = false) {
+    const check = await requireAdvanced("get_fps_stats");
+    if (!check.allowed)
+        return check.message;
+    const deviceFlag = device ? `-s ${device}` : "";
+    try {
+        const resultLines = [];
+        resultLines.push("🎮 Frame Rendering Stats (FPS)");
+        resultLines.push("═".repeat(50));
+        resultLines.push(`\n📱 App: ${packageName}\n`);
+        // Reset stats if requested
+        if (reset) {
+            await execAsync(`adb ${deviceFlag} shell dumpsys gfxinfo ${packageName} reset`);
+            resultLines.push("📊 Stats reset. Interact with the app, then run this tool again.\n");
+        }
+        // Get graphics info
+        const { stdout: gfxInfo } = await execAsync(`adb ${deviceFlag} shell dumpsys gfxinfo ${packageName}`, { maxBuffer: 2 * 1024 * 1024 });
+        const lines = gfxInfo.split("\n");
+        // Parse total frames
+        const totalMatch = gfxInfo.match(/Total frames rendered:\s*(\d+)/);
+        const jankyMatch = gfxInfo.match(/Janky frames:\s*(\d+)\s*\(([^)]+)\)/);
+        const percentile50 = gfxInfo.match(/50th percentile:\s*(\d+)ms/);
+        const percentile90 = gfxInfo.match(/90th percentile:\s*(\d+)ms/);
+        const percentile95 = gfxInfo.match(/95th percentile:\s*(\d+)ms/);
+        const percentile99 = gfxInfo.match(/99th percentile:\s*(\d+)ms/);
+        if (totalMatch) {
+            const totalFrames = parseInt(totalMatch[1]);
+            resultLines.push(`📈 Total Frames: ${totalFrames}`);
+            if (jankyMatch) {
+                const jankyFrames = parseInt(jankyMatch[1]);
+                const jankyPercent = jankyMatch[2];
+                resultLines.push(`🐌 Janky Frames: ${jankyFrames} (${jankyPercent})`);
+                // Calculate smooth FPS estimate
+                const smoothFrames = totalFrames - jankyFrames;
+                const smoothPercent = ((smoothFrames / totalFrames) * 100).toFixed(1);
+                resultLines.push(`✨ Smooth Frames: ${smoothFrames} (${smoothPercent}%)`);
+            }
+        }
+        // Frame timing percentiles
+        if (percentile50 || percentile90) {
+            resultLines.push("\n⏱️  Frame Time Percentiles:");
+            if (percentile50)
+                resultLines.push(`  50th: ${percentile50[1]}ms`);
+            if (percentile90)
+                resultLines.push(`  90th: ${percentile90[1]}ms`);
+            if (percentile95)
+                resultLines.push(`  95th: ${percentile95[1]}ms`);
+            if (percentile99)
+                resultLines.push(`  99th: ${percentile99[1]}ms`);
+        }
+        // Look for slow frames breakdown
+        const slowUIMatch = gfxInfo.match(/Number Slow UI thread:\s*(\d+)/);
+        const slowBitmapMatch = gfxInfo.match(/Number Slow bitmap uploads:\s*(\d+)/);
+        const slowDrawMatch = gfxInfo.match(/Number Slow issue draw commands:\s*(\d+)/);
+        if (slowUIMatch || slowBitmapMatch || slowDrawMatch) {
+            resultLines.push("\n🔍 Slow Frame Analysis:");
+            if (slowUIMatch && parseInt(slowUIMatch[1]) > 0) {
+                resultLines.push(`  Slow UI thread: ${slowUIMatch[1]}`);
+            }
+            if (slowBitmapMatch && parseInt(slowBitmapMatch[1]) > 0) {
+                resultLines.push(`  Slow bitmap uploads: ${slowBitmapMatch[1]}`);
+            }
+            if (slowDrawMatch && parseInt(slowDrawMatch[1]) > 0) {
+                resultLines.push(`  Slow draw commands: ${slowDrawMatch[1]}`);
+            }
+        }
+        // Performance recommendation
+        if (jankyMatch) {
+            const jankyPercent = parseFloat(jankyMatch[2]);
+            if (jankyPercent > 10) {
+                resultLines.push("\n⚠️  Performance Issue: High jank percentage");
+                resultLines.push("   Consider optimizing heavy UI operations");
+            }
+            else if (jankyPercent < 5) {
+                resultLines.push("\n✅ Good Performance: Low jank percentage");
+            }
+        }
+        if (!totalMatch) {
+            resultLines.push("No frame data available.");
+            resultLines.push("Make sure the app is visible and interact with it first.");
+        }
+        let result = resultLines.join("\n");
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    catch (error) {
+        let result = `Error getting FPS stats: ${error.message}`;
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+}
+async function getBatteryStats(packageName, device) {
+    const check = await requireAdvanced("get_battery_stats");
+    if (!check.allowed)
+        return check.message;
+    const deviceFlag = device ? `-s ${device}` : "";
+    try {
+        const resultLines = [];
+        resultLines.push("🔋 Battery Statistics");
+        resultLines.push("═".repeat(50));
+        // Get current battery level and status
+        const { stdout: batteryInfo } = await execAsync(`adb ${deviceFlag} shell dumpsys battery`, { timeout: 5000 });
+        const levelMatch = batteryInfo.match(/level:\s*(\d+)/);
+        const statusMatch = batteryInfo.match(/status:\s*(\d+)/);
+        const healthMatch = batteryInfo.match(/health:\s*(\d+)/);
+        const tempMatch = batteryInfo.match(/temperature:\s*(\d+)/);
+        resultLines.push("\n📊 Current Status:");
+        if (levelMatch) {
+            resultLines.push(`  Battery Level: ${levelMatch[1]}%`);
+        }
+        if (statusMatch) {
+            const statuses = ["Unknown", "Charging", "Discharging", "Not charging", "Full"];
+            const status = statuses[parseInt(statusMatch[1])] || "Unknown";
+            resultLines.push(`  Status: ${status}`);
+        }
+        if (tempMatch) {
+            const temp = parseInt(tempMatch[1]) / 10;
+            resultLines.push(`  Temperature: ${temp}°C`);
+        }
+        // Get battery stats (power consumption)
+        if (packageName) {
+            resultLines.push(`\n📱 App: ${packageName}`);
+            try {
+                const { stdout: appStats } = await execAsync(`adb ${deviceFlag} shell dumpsys batterystats ${packageName}`, { maxBuffer: 5 * 1024 * 1024, timeout: 10000 });
+                // Parse power usage
+                const powerMatch = appStats.match(/Estimated power use \(mAh\)[\s\S]*?Uid \S+:\s*([\d.]+)/);
+                if (powerMatch) {
+                    resultLines.push(`  Power Used: ${powerMatch[1]} mAh`);
+                }
+                // CPU time
+                const cpuMatch = appStats.match(/Total cpu time:\s*u=(\d+)ms\s*s=(\d+)ms/);
+                if (cpuMatch) {
+                    const userMs = parseInt(cpuMatch[1]);
+                    const sysMs = parseInt(cpuMatch[2]);
+                    resultLines.push(`  CPU Time: ${((userMs + sysMs) / 1000).toFixed(1)}s (user: ${(userMs / 1000).toFixed(1)}s, sys: ${(sysMs / 1000).toFixed(1)}s)`);
+                }
+                // Network usage
+                const networkMatch = appStats.match(/Network:\s*([\d.]+)\s*MB\s*received,\s*([\d.]+)\s*MB\s*transmitted/i);
+                if (networkMatch) {
+                    resultLines.push(`  Network: ${networkMatch[1]} MB ↓, ${networkMatch[2]} MB ↑`);
+                }
+                // Wakelock time
+                const wakelockMatch = appStats.match(/Wake lock\s+\S+\s+.*?realtime=(\d+)/);
+                if (wakelockMatch) {
+                    const wakeSec = parseInt(wakelockMatch[1]) / 1000;
+                    if (wakeSec > 0) {
+                        resultLines.push(`  Wake Lock: ${wakeSec.toFixed(1)}s`);
+                    }
+                }
+            }
+            catch {
+                resultLines.push("  Detailed stats not available for this app");
+            }
+        }
+        else {
+            // Show top battery consumers
+            resultLines.push("\n🔝 Top Power Consumers:");
+            try {
+                const { stdout: stats } = await execAsync(`adb ${deviceFlag} shell dumpsys batterystats`, { maxBuffer: 10 * 1024 * 1024, timeout: 15000 });
+                // Parse estimated power section
+                const powerSection = stats.match(/Estimated power use[\s\S]*?(?=\n\n|\nStatistics)/);
+                if (powerSection) {
+                    const powerLines = powerSection[0].split("\n").slice(1, 8);
+                    powerLines.forEach(line => {
+                        const trimmed = line.trim();
+                        if (trimmed && !trimmed.startsWith("Estimated")) {
+                            resultLines.push(`  ${trimmed}`);
+                        }
+                    });
+                }
+            }
+            catch {
+                resultLines.push("  Could not retrieve detailed battery stats");
+            }
+        }
+        let result = resultLines.join("\n");
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    catch (error) {
+        let result = `Error getting battery stats: ${error.message}`;
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+}
+async function getPerformanceSnapshot(packageName, device) {
+    const check = await requireAdvanced("get_performance_snapshot");
+    if (!check.allowed)
+        return check.message;
+    const deviceFlag = device ? `-s ${device}` : "";
+    try {
+        const resultLines = [];
+        resultLines.push("📊 Performance Snapshot");
+        resultLines.push("═".repeat(50));
+        resultLines.push(`\n📱 App: ${packageName}`);
+        resultLines.push(`⏰ Time: ${new Date().toLocaleString()}\n`);
+        // CPU Usage
+        try {
+            const { stdout: cpuInfo } = await execAsync(`adb ${deviceFlag} shell dumpsys cpuinfo | grep -i "${packageName}"`, { timeout: 5000 });
+            if (cpuInfo.trim()) {
+                resultLines.push("💻 CPU:");
+                cpuInfo.split("\n").slice(0, 3).forEach(line => {
+                    if (line.trim())
+                        resultLines.push(`  ${line.trim()}`);
+                });
+            }
+        }
+        catch {
+            resultLines.push("💻 CPU: N/A");
+        }
+        // Memory Usage
+        try {
+            const { stdout: memInfo } = await execAsync(`adb ${deviceFlag} shell dumpsys meminfo ${packageName}`, { maxBuffer: 2 * 1024 * 1024, timeout: 5000 });
+            const pssMatch = memInfo.match(/TOTAL PSS:\s*(\d+)/i) || memInfo.match(/TOTAL:\s+(\d+)/);
+            if (pssMatch) {
+                const pssMb = (parseInt(pssMatch[1]) / 1024).toFixed(1);
+                resultLines.push(`\n🧠 Memory: ${pssMb} MB (PSS)`);
+            }
+            const heapMatch = memInfo.match(/Java Heap:\s+(\d+)/);
+            const nativeMatch = memInfo.match(/Native Heap:\s+(\d+)/);
+            if (heapMatch) {
+                resultLines.push(`   Java Heap: ${(parseInt(heapMatch[1]) / 1024).toFixed(1)} MB`);
+            }
+            if (nativeMatch) {
+                resultLines.push(`   Native: ${(parseInt(nativeMatch[1]) / 1024).toFixed(1)} MB`);
+            }
+        }
+        catch {
+            resultLines.push("\n🧠 Memory: App not running or no data");
+        }
+        // FPS Stats
+        try {
+            const { stdout: gfxInfo } = await execAsync(`adb ${deviceFlag} shell dumpsys gfxinfo ${packageName}`, { maxBuffer: 1024 * 1024, timeout: 5000 });
+            const totalMatch = gfxInfo.match(/Total frames rendered:\s*(\d+)/);
+            const jankyMatch = gfxInfo.match(/Janky frames:\s*(\d+)\s*\(([^)]+)\)/);
+            if (totalMatch) {
+                resultLines.push(`\n🎮 Frames: ${totalMatch[1]} rendered`);
+                if (jankyMatch) {
+                    resultLines.push(`   Janky: ${jankyMatch[1]} (${jankyMatch[2]})`);
+                }
+            }
+        }
+        catch {
+            resultLines.push("\n🎮 Frames: No data");
+        }
+        // Battery
+        try {
+            const { stdout: batteryInfo } = await execAsync(`adb ${deviceFlag} shell dumpsys battery`, { timeout: 3000 });
+            const levelMatch = batteryInfo.match(/level:\s*(\d+)/);
+            const tempMatch = batteryInfo.match(/temperature:\s*(\d+)/);
+            if (levelMatch) {
+                resultLines.push(`\n🔋 Battery: ${levelMatch[1]}%`);
+                if (tempMatch) {
+                    resultLines.push(`   Temperature: ${parseInt(tempMatch[1]) / 10}°C`);
+                }
+            }
+        }
+        catch {
+            resultLines.push("\n🔋 Battery: N/A");
+        }
+        // Network usage from app
+        try {
+            const { stdout: netStats } = await execAsync(`adb ${deviceFlag} shell cat /proc/net/xt_qtaguid/stats`, { timeout: 3000 });
+            // Just note that network is available
+            if (netStats.includes(packageName)) {
+                resultLines.push("\n📡 Network: Active");
+            }
+        }
+        catch {
+            // Network stats not available
+        }
+        resultLines.push("\n" + "─".repeat(50));
+        resultLines.push("Use individual tools for detailed metrics:");
+        resultLines.push("  get_cpu_usage, get_memory_usage, get_fps_stats, get_battery_stats");
+        let result = resultLines.join("\n");
+        if (check.message)
+            result += `\n\n${check.message}`;
+        return result;
+    }
+    catch (error) {
+        let result = `Error getting performance snapshot: ${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_adb_logs": {
+                const result = await getAdbLogs(args?.lines, args?.filter, args?.level);
+                return { content: [{ type: "text", text: result }] };
+            }
+            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 });
+                    }
+                    return { content };
+                }
+                return { content: [{ type: "text", text: result.error }] };
+            }
+            case "list_devices": {
+                const result = await listDevices();
                 return { content: [{ type: "text", text: result }] };
             }
             case "check_metro_status": {
@@ -2289,6 +3581,69 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const result = await searchReactComponents(args?.query, args?.port);
                 return { content: [{ type: "text", text: result }] };
             }
+            // NETWORK INSPECTION TOOLS
+            case "get_network_requests": {
+                const result = await getNetworkRequests(args?.lines, args?.filter, args?.device);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "start_network_monitoring": {
+                const result = await startNetworkMonitoring(args?.device);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "stop_network_monitoring": {
+                const result = await stopNetworkMonitoring();
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "get_network_stats": {
+                const result = await getNetworkStats(args?.device);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "analyze_request": {
+                const result = await analyzeRequest(args?.index);
+                return { content: [{ type: "text", text: result }] };
+            }
+            // EXPO DEVTOOLS TOOLS
+            case "check_expo_status": {
+                const result = await checkExpoStatus(args?.port);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "get_expo_config": {
+                const result = await getExpoConfig(args?.projectPath);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "expo_dev_menu": {
+                const result = await expoDevMenu(args?.device);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "expo_reload": {
+                const result = await expoReload(args?.device);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "get_eas_builds": {
+                const result = await getEasBuilds(args?.platform, args?.limit);
+                return { content: [{ type: "text", text: result }] };
+            }
+            // PERFORMANCE METRICS TOOLS
+            case "get_cpu_usage": {
+                const result = await getCpuUsage(args?.packageName, args?.device);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "get_memory_usage": {
+                const result = await getMemoryUsage(args?.packageName, args?.device);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "get_fps_stats": {
+                const result = await getFpsStats(args?.packageName, args?.device, args?.reset);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "get_battery_stats": {
+                const result = await getBatteryStats(args?.packageName, args?.device);
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "get_performance_snapshot": {
+                const result = await getPerformanceSnapshot(args?.packageName, args?.device);
+                return { content: [{ type: "text", text: result }] };
+            }
             default:
                 return {
                     content: [{ type: "text", text: `Unknown tool: ${name}` }],