mobile-mcp-server 1.0.6 → 1.1.1

package/dist/config/env.d.ts

@@ -10,4 +10,3 @@ export declare const APPIUM_HOST: string;
 export declare const APPIUM_PORT: number;
 export type LogLevel = "debug" | "info" | "warn" | "error";
 export declare const LOG_LEVEL: LogLevel;
-export declare const MCP_API_KEY: string;

package/dist/config/env.js

@@ -11,5 +11,3 @@ export const SCREENSHOT_TIMEOUT = 10000;
 export const APPIUM_HOST = process.env.APPIUM_HOST || "127.0.0.1";
 export const APPIUM_PORT = parseInt(process.env.APPIUM_PORT || "4723", 10);
 export const LOG_LEVEL = process.env.LOG_LEVEL || "info";
-// Security
-export const MCP_API_KEY = process.env.MCP_API_KEY || "hash2026";

package/dist/config/paths.d.ts

@@ -1,8 +1,5 @@
 export declare const ANDROID_HOME: string;
 export declare const ADB_PATH: string;
-export declare const EMULATOR_PATH: string;
-export declare const ARTIFACTS_ROOT: string;
 export declare const LOG_DIR: string;
 export declare const SCREENSHOT_DIR: string;
-export declare const APK_DIR: string;
 export declare const DOWNLOADS_DIR: string;

package/dist/config/paths.js

@@ -7,16 +7,10 @@ import { dirname } from "path";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Android SDK paths
-export const ANDROID_HOME = process.env.ANDROID_HOME || "E:\\Android\\Sdk";
+export const ANDROID_HOME = process.env.ANDROID_HOME || "D:\\Android";
 export const ADB_PATH = process.env.ADB_PATH || join(ANDROID_HOME, "platform-tools", "adb.exe");
-export const EMULATOR_PATH = process.env.EMULATOR_PATH || join(ANDROID_HOME, "emulator", "emulator.exe");
-// Strict Artifact Paths (LOCKED by User Constraints)
-export const ARTIFACTS_ROOT = "D:\\Automation\\artifacts";
-export const LOG_DIR = join(ARTIFACTS_ROOT, "logs");
-export const SCREENSHOT_DIR = join(ARTIFACTS_ROOT, "shots"); // Strictly "shots", not "screenshots"
-export const APK_DIR = join(ARTIFACTS_ROOT, "apks");
-// Map "downloads" to apks directory for now, or a temp dir if needed, 
-// but user only gave us 3 allowlisted buckets. Let's force downloads to be treated as APKs if they are APKs.
-// or just put them in a temp folder inside artifacts if generic.
-// For now, I will add a strict DOWNLOADS_DIR that maps to apks for consistency with user constraints on APKs.
-export const DOWNLOADS_DIR = APK_DIR;
+// Project directories
+const PROJECT_ROOT = join(__dirname, "..");
+export const LOG_DIR = join(PROJECT_ROOT, "logs");
+export const SCREENSHOT_DIR = join(PROJECT_ROOT, "screenshots");
+export const DOWNLOADS_DIR = join(PROJECT_ROOT, "downloads");

package/dist/logs/2026-02-10.log

@@ -0,0 +1 @@
+{"timestamp":"2026-02-10T13:08:39.593Z","level":"info","message":"TOOL: adb_devices","data":{"input":{},"success":true,"error":null}}

package/dist/prompts/connection.prompts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Connection Prompts
+ * Templates to guide the user through device connection workflows
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConnectionPrompts(server: McpServer): void;

package/dist/prompts/connection.prompts.js

@@ -0,0 +1,42 @@
+export function registerConnectionPrompts(server) {
+    server.prompt("connect_mobile_wifi", "Workflow to connect a physical Android device via WiFi", async () => ({
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Connect to my Android device via WiFi.
+
+**Prerequisites**
+1. Connect phone and computer to the same WiFi.
+2. Enable "Wireless Debugging" on the phone.
+3. Obtain the device IP address (e.g., 192.168.1.50).
+
+**Execution Steps**
+1. Request the Device IP if missing.
+2. Call \`adb_connect_wifi({ ip: "IP_ADDRESS" })\`.
+3. Verify connection with \`check_device_online\`.
+
+**Example**
+User: "Connect to 192.168.1.45"
+Assistant: Calls \`adb_connect_wifi("192.168.1.45")\`
+`
+                }
+            }]
+    }));
+    server.prompt("setup_physical_device", "Guide to enable Developer Options and USB Debugging", async () => ({
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Set up Android device for automation.
+
+1. Open **Settings > About Phone**.
+2. Tap **Build Number** 7 times to enable Developer Options.
+3. Open **Settings > System > Developer Options**.
+4. Enable **USB Debugging**.
+5. Enable **Wireless Debugging** to view the IP address.
+`
+                }
+            }]
+    }));
+}

package/dist/server.d.ts

@@ -1,10 +1,2 @@
-/**
- * Mobile Automation MCP Server
- * Entry point for the MCP server that provides mobile automation tools
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-/**
- * Creates and configures the MCP Server instance
- * Registers all tools, resources, and prompts
- */
-export declare function createMcpServer(): McpServer;
+#!/usr/bin/env node
+export {};

package/dist/server.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 /**
  * Mobile Automation MCP Server
  * Entry point for the MCP server that provides mobile automation tools
@@ -10,51 +11,32 @@ import { registerApkTools } from "./tools/apk.tools.js";
 import { registerAppTools } from "./tools/app.tools.js";
 import { registerEvidenceTools } from "./tools/evidence.tools.js";
 import { registerAppiumTools } from "./tools/appium.tools.js";
-import { registerSmartTools } from "./tools/smart.tools.js";
-import { registerUtilityTools } from "./tools/utility.tools.js";
-// Import control plane registration functions
-import { registerMobileResources } from "./resources/mobile.resources.js";
-import { registerMobilePrompts } from "./prompts/mobile.prompts.js";
+import { registerIosTools } from "./tools/ios.tools.js";
+import { registerConnectionPrompts } from "./prompts/connection.prompts.js";
 import { SERVER_NAME, SERVER_VERSION } from "./config/env.js";
-/**
- * Creates and configures the MCP Server instance
- * Registers all tools, resources, and prompts
- */
-export function createMcpServer() {
-    // Create server instance
-    const server = new McpServer({
-        name: SERVER_NAME,
-        version: SERVER_VERSION,
-    });
-    // Register all tool domains
-    // Device Tools: adb_devices, check_device_online, get_device_info
-    registerDeviceTools(server);
-    // APK Tools: install_apk, uninstall_app, clear_app_data, list_packages, download_apk
-    registerApkTools(server);
-    // App Tools: launch_app, launch_activity, force_stop_app, open_deep_link, open_url_in_browser
-    registerAppTools(server);
-    // Evidence Tools: take_screenshot, get_logcat, get_page_source
-    registerEvidenceTools(server);
-    // Appium Tools: tap, type_text, swipe, press_key, long_press
-    registerAppiumTools(server);
-    // Smart Tools: smart_click, wait_for_text, get_ui_inventory
-    registerSmartTools(server);
-    // Utility Tools: wait
-    registerUtilityTools(server);
-    // Register Control Plane (Resources & Prompts)
-    registerMobileResources(server);
-    registerMobilePrompts(server);
-    return server;
-}
-// Start the server with stdio transport if running directly
-// This maintains the original behavior for local stdio usage
+// Create server instance
+const server = new McpServer({
+    name: SERVER_NAME,
+    version: SERVER_VERSION,
+});
+// Register all tool domains
+// Device Tools: adb_devices, check_device_online, get_device_info
+registerDeviceTools(server);
+// APK Tools: install_apk, uninstall_app, clear_app_data, list_packages, download_apk
+registerApkTools(server);
+// App Tools: launch_app, launch_activity, force_stop_app, open_deep_link, open_url_in_browser
+registerAppTools(server);
+// Evidence Tools: take_screenshot, get_logcat, get_page_source
+registerEvidenceTools(server);
+// Appium Tools: tap, type_text, swipe, press_key, long_press
+registerAppiumTools(server);
+// iOS Tools: list_devices, boot_device, install_app, launch_app, screenshot
+registerIosTools(server);
+// Prompts: connect_mobile_wifi, setup_physical_device
+registerConnectionPrompts(server);
+// Start the server with stdio transport
 async function main() {
-    const server = createMcpServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }
-// Only run main if called directly (not imported)
-import { fileURLToPath } from "url";
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    main().catch(console.error);
-}
+main().catch(console.error);

package/dist/server_http.js

@@ -0,0 +1,60 @@
+import express from "express";
+import cors from "cors";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+// Import tool domain registration functions
+import { registerDeviceTools } from "./tools/device.tools.js";
+import { registerApkTools } from "./tools/apk.tools.js";
+import { registerAppTools } from "./tools/app.tools.js";
+import { registerEvidenceTools } from "./tools/evidence.tools.js";
+import { registerAppiumTools } from "./tools/appium.tools.js";
+import { SERVER_NAME, SERVER_VERSION } from "./config/env.js";
+const app = express();
+const PORT = 7000;
+app.use(cors());
+// app.use(express.json()); // Optional, handled by transport usually
+// Create server instance
+const server = new McpServer({
+    name: SERVER_NAME,
+    version: SERVER_VERSION,
+});
+// Register all tool domains
+registerDeviceTools(server);
+registerApkTools(server);
+registerAppTools(server);
+registerEvidenceTools(server);
+registerAppiumTools(server);
+// Store transports mapping sessionId -> transport
+const transports = new Map();
+// SSE Endpoint
+app.get("/mcp", async (req, res) => {
+    console.log("New SSE connection attempt");
+    const transport = new SSEServerTransport("/message", res);
+    // SDK generates sessionId
+    const sessionId = transport.sessionId;
+    transports.set(sessionId, transport);
+    req.on("close", () => {
+        console.log(`SSE connection closed: ${sessionId}`);
+        transports.delete(sessionId);
+    });
+    await server.connect(transport);
+});
+// Message Endpoint (POST)
+app.post("/message", async (req, res) => {
+    const sessionId = req.query.sessionId;
+    if (!sessionId) {
+        res.status(400).send("Missing sessionId");
+        return;
+    }
+    const transport = transports.get(sessionId);
+    if (!transport) {
+        res.status(404).send("Session not found");
+        return;
+    }
+    await transport.handlePostMessage(req, res);
+});
+// Start Server
+app.listen(PORT, "0.0.0.0", () => {
+    console.log(`Mobile MCP Server (HTTP/SSE) running on http://0.0.0.0:${PORT}`);
+    console.log(`SSE Endpoint: http://localhost:${PORT}/mcp`);
+});

package/dist/tools/apk.tools.js

@@ -6,10 +6,9 @@ import { z } from "zod";
 import { adb } from "../utils/exec.js";
 import { logToolExecution } from "../utils/logger.js";
 import { APK_INSTALL_TIMEOUT } from "../config/env.js";
-import { DOWNLOADS_DIR } from "../config/paths.js";
-import { validateArtifactPath } from "../utils/validator.js";
-import { writeFile, mkdir } from "fs/promises";
-import { dirname } from "path";
+import { SCREENSHOT_DIR } from "../config/paths.js";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
 /**
  * Register all APK management tools
  */
@@ -20,17 +19,6 @@ export function registerApkTools(server) {
         device_id: z.string().optional().describe("Target device ID (optional if only one device)"),
         reinstall: z.boolean().optional().describe("Reinstall the app, keeping data (default: false)"),
     }, async ({ apk_path, device_id, reinstall }) => {
-        // Validate that we are only installing from allowed directories is good practice, 
-        // but for now we just need to ensure the path is safe if we were reading it.
-        // Since ADB installs it, we just pass the path. 
-        // However, the user said "Tools must accept explicit paths, validate allowed directories".
-        // So we should strictly check if the APK is in our APK_DIR? 
-        // The prompt says "Tools must accept explicit paths", which usually implies input validation.
-        // I will add a check to warn or block if it's not in ARTIFACTS_ROOT, but for flexibility 
-        // (maybe installing a system apk?) I might leave it open or just warn.
-        // Given "Strict File System Rules", I'll enforce it must be within ARTIFACTS_ROOT.
-        // For now, let's trust the user's explicit path but ensure it exists? 
-        // The `adb install` will fail if it doesn't exist.
         const deviceFlag = device_id ? `-s ${device_id}` : "";
         const reinstallFlag = reinstall ? "-r" : "";
         const result = await adb(`${deviceFlag} install ${reinstallFlag} "${apk_path}"`, { timeout: APK_INSTALL_TIMEOUT });
@@ -126,14 +114,10 @@ export function registerApkTools(server) {
         install: z.boolean().optional().describe("Install APK after download (default: true)"),
         device_id: z.string().optional().describe("Target device ID for installation"),
     }, async ({ url, filename, install = true, device_id }) => {
-        // FORCE validation of the target path
-        const safeFilename = filename || `downloaded_${Date.now()}.apk`;
-        const finalApkPath = validateArtifactPath(safeFilename, DOWNLOADS_DIR);
-        // We don't need to mkdir logic here if we assume DOWNLOADS_DIR exists, 
-        // but it might not. Safest to keep it? 
-        // But strict rules say D:\Automation\artifacts\apks exists. 
-        // I'll keep the logic but use the validated path.
-        await mkdir(dirname(finalApkPath), { recursive: true });
+        const downloadsDir = join(SCREENSHOT_DIR, "..", "downloads");
+        await mkdir(downloadsDir, { recursive: true });
+        const apkFilename = filename || `downloaded_${Date.now()}.apk`;
+        const apkPath = join(downloadsDir, apkFilename);
         try {
             const response = await fetch(url);
             if (!response.ok) {
@@ -149,15 +133,15 @@ export function registerApkTools(server) {
                 };
             }
             const arrayBuffer = await response.arrayBuffer();
-            await writeFile(finalApkPath, Buffer.from(arrayBuffer));
+            await writeFile(apkPath, Buffer.from(arrayBuffer));
             let installResult = null;
             if (install) {
                 const deviceFlag = device_id ? `-s ${device_id}` : "";
-                installResult = await adb(`${deviceFlag} install -r "${finalApkPath}"`, { timeout: APK_INSTALL_TIMEOUT });
+                installResult = await adb(`${deviceFlag} install -r "${apkPath}"`, { timeout: APK_INSTALL_TIMEOUT });
             }
             const output = {
                 success: true,
-                downloaded_to: finalApkPath,
+                downloaded_to: apkPath,
                 file_size_mb: (arrayBuffer.byteLength / (1024 * 1024)).toFixed(2),
                 installed: install ? (installResult?.success && installResult?.stdout?.includes("Success")) : false,
                 install_output: install ? installResult?.stdout?.trim() : null,

package/dist/tools/appium.tools.js

@@ -1,10 +1,6 @@
 /**
  * Appium UI Automation Tools Domain
  * Tools for direct UI interaction (tap, type, swipe, etc.)
- *
- * NOTE: This module currently uses ADB commands (`input tap`, `input swipe`)
- * to simulate Appium interactions. This provides a lightweight, dependency-free
- * alternative to running a full Appium node for basic coordinate-based automation.
  */
 import { z } from "zod";
 import { adb } from "../utils/exec.js";

package/dist/tools/device.tools.js

@@ -3,7 +3,7 @@
  * Tools for device discovery and status checking
  */
 import { z } from "zod";
-import { adb, emulator, startEmulatorBackground } from "../utils/exec.js";
+import { adb } from "../utils/exec.js";
 import { logToolExecution } from "../utils/logger.js";
 /**
  * Register all device tools
@@ -77,32 +77,22 @@ export function registerDeviceTools(server) {
             content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
         };
     });
-    // Tool: list_avds
-    server.tool("list_avds", "List all available Android Virtual Devices (AVDs)", {}, async () => {
-        const result = await emulator("-list-avds");
-        const avds = result.stdout.trim().split("\n").filter(line => line.trim());
+    // Tool: adb_connect_wifi
+    server.tool("adb_connect_wifi", "Connect to an Android device via WiFi (requires IP address)", {
+        ip: z.string().describe("IP address of the device (e.g., 192.168.1.50)"),
+        port: z.number().optional().describe("Port number (default: 5555)"),
+    }, async ({ ip, port = 5555 }) => {
+        const result = await adb(`connect ${ip}:${port}`);
+        // Check output for success
+        const success = result.success && (result.stdout.includes("connected to") || result.stdout.includes("already connected"));
         const output = {
-            success: result.success,
-            avd_count: avds.length,
-            avds: avds,
-            error: result.error,
-        };
-        await logToolExecution("list_avds", {}, output);
-        return {
-            content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-        };
-    });
-    // Tool: start_emulator
-    server.tool("start_emulator", "Start a specific Android emulator (AVD) in the background", {
-        avd_name: z.string().describe("Name of the AVD to start (get from list_avds)"),
-    }, async ({ avd_name }) => {
-        await startEmulatorBackground(avd_name);
-        const output = {
-            success: true,
-            message: `Emulator ${avd_name} starting in background...`,
-            avd_name: avd_name,
+            success: success,
+            action: "adb_connect",
+            target: `${ip}:${port}`,
+            message: result.stdout.trim(),
+            error: result.error
         };
-        await logToolExecution("start_emulator", { avd_name }, output);
+        await logToolExecution("adb_connect_wifi", { ip, port }, output);
         return {
             content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
         };

package/dist/tools/evidence.tools.js

@@ -5,10 +5,9 @@
 import { z } from "zod";
 import { adb } from "../utils/exec.js";
 import { logToolExecution } from "../utils/logger.js";
-import { SCREENSHOT_DIR, LOG_DIR } from "../config/paths.js";
-import { validateArtifactPath } from "../utils/validator.js";
+import { SCREENSHOT_DIR } from "../config/paths.js";
 import { writeFile, mkdir, readFile } from "fs/promises";
-import { dirname } from "path";
+import { join, dirname } from "path";
 /**
  * Register all evidence capture tools
  */
@@ -16,21 +15,12 @@ export function registerEvidenceTools(server) {
     // Tool: take_screenshot
     server.tool("take_screenshot", "Capture a screenshot from the device and display it inline (also saves to file)", {
         filename: z.string().optional().describe("Screenshot filename (default: timestamp.png)"),
-        output_path: z.string().optional().describe("Full path to save (overrides default screenshots dir, must be in artifacts)"),
+        output_path: z.string().optional().describe("Full path to save (overrides default screenshots dir)"),
         device_id: z.string().optional().describe("Target device ID"),
     }, async ({ filename, output_path, device_id }) => {
         const deviceFlag = device_id ? `-s ${device_id}` : "";
         const defaultFilename = `screenshot_${Date.now()}.png`;
-        // Validate the path. If output_path is provided, it must be valid. 
-        // If filename is provided, it must be within SCREENSHOT_DIR.
-        // We use validateArtifactPath which handles both absolute and relative-to-root logic.
-        let finalPath;
-        if (output_path) {
-            finalPath = validateArtifactPath(output_path, SCREENSHOT_DIR);
-        }
-        else {
-            finalPath = validateArtifactPath(filename || defaultFilename, SCREENSHOT_DIR);
-        }
+        const finalPath = output_path || join(SCREENSHOT_DIR, filename || defaultFilename);
         await mkdir(dirname(finalPath), { recursive: true });
         const tempPath = "/sdcard/mcp_screenshot.png";
         await adb(`${deviceFlag} shell screencap -p ${tempPath}`);
@@ -68,20 +58,19 @@ export function registerEvidenceTools(server) {
         device_id: z.string().optional().describe("Target device ID"),
         filter: z.string().optional().describe("Filter by tag or priority (e.g., 'MyApp:D *:S')"),
         lines: z.number().optional().describe("Number of recent lines to fetch (default: 100)"),
-        save_to: z.string().optional().describe("Optional path to save logs to file (must be in artifacts)"),
+        save_to: z.string().optional().describe("Optional path to save logs to file"),
     }, async ({ device_id, filter, lines = 100, save_to }) => {
         const deviceFlag = device_id ? `-s ${device_id}` : "";
         const filterStr = filter ? ` ${filter}` : "";
         const result = await adb(`${deviceFlag} logcat -d -t ${lines}${filterStr}`, { maxBuffer: 5 * 1024 * 1024 });
         if (save_to && result.success) {
-            const finalPath = validateArtifactPath(save_to, LOG_DIR);
-            await mkdir(dirname(finalPath), { recursive: true });
-            await writeFile(finalPath, result.stdout);
+            await mkdir(dirname(save_to), { recursive: true });
+            await writeFile(save_to, result.stdout);
         }
         const output = {
             success: result.success,
             lines_count: result.stdout.split("\n").length,
-            saved_to: save_to ? validateArtifactPath(save_to, LOG_DIR) : null,
+            saved_to: save_to || null,
             logs: result.stdout,
             error: result.error,
         };
@@ -93,20 +82,19 @@ export function registerEvidenceTools(server) {
     // Tool: get_page_source
     server.tool("get_page_source", "Dump the current UI hierarchy (XML) from the device", {
         device_id: z.string().optional().describe("Target device ID"),
-        save_to: z.string().optional().describe("Optional path to save XML to file (must be in artifacts)"),
+        save_to: z.string().optional().describe("Optional path to save XML to file"),
     }, async ({ device_id, save_to }) => {
         const deviceFlag = device_id ? `-s ${device_id}` : "";
         await adb(`${deviceFlag} shell uiautomator dump /sdcard/ui_dump.xml`);
         const result = await adb(`${deviceFlag} shell cat /sdcard/ui_dump.xml`);
         await adb(`${deviceFlag} shell rm /sdcard/ui_dump.xml`);
         if (save_to && result.success) {
-            const finalPath = validateArtifactPath(save_to, LOG_DIR);
-            await mkdir(dirname(finalPath), { recursive: true });
-            await writeFile(finalPath, result.stdout);
+            await mkdir(dirname(save_to), { recursive: true });
+            await writeFile(save_to, result.stdout);
         }
         const output = {
             success: result.success,
-            saved_to: save_to ? validateArtifactPath(save_to, LOG_DIR) : null,
+            saved_to: save_to || null,
             xml: result.stdout,
             error: result.error,
         };

package/dist/tools/ios.tools.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register all iOS Simulator tools
+ */
+export declare function registerIosTools(server: McpServer): void;

package/dist/tools/ios.tools.js

@@ -0,0 +1,123 @@
+/**
+ * iOS Simulator Tools Domain
+ * Tools for managing iOS Simulators via 'xcrun simctl'
+ * Priority: Mac First Strategy
+ */
+import { z } from "zod";
+import { run } from "../utils/exec.js";
+import { logToolExecution } from "../utils/logger.js";
+import { join } from "path";
+import { SCREENSHOT_DIR } from "../config/paths.js";
+/**
+ * Register all iOS Simulator tools
+ */
+export function registerIosTools(server) {
+    // Tool: ios_list_devices
+    server.tool("ios_list_devices", "List all available iOS Simulators", {
+        state: z.enum(["shutdown", "booted", "all"]).optional().describe("Filter by state"),
+    }, async ({ state = "all" }) => {
+        const result = await run("xcrun simctl list devices --json");
+        if (!result.success) {
+            return {
+                content: [{ type: "text", text: `Error listing devices: ${result.stderr}` }],
+                isError: true,
+            };
+        }
+        try {
+            const data = JSON.parse(result.stdout);
+            let devices = [];
+            for (const runtime in data.devices) {
+                devices = devices.concat(data.devices[runtime]);
+            }
+            if (state !== "all") {
+                devices = devices.filter((d) => d.state.toLowerCase() === state.toLowerCase());
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(devices, null, 2) }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Error parsing JSON: ${e}` }],
+                isError: true,
+            };
+        }
+    });
+    // Tool: ios_boot_device
+    server.tool("ios_boot_device", "Boot an iOS Simulator", {
+        udid: z.string().describe("Device UDID"),
+    }, async ({ udid }) => {
+        const result = await run(`xcrun simctl boot ${udid}`);
+        // If already booted, simctl returns error but that's fine for us usually
+        // We can check `result.stderr` for "Unable to boot device in current state: Booted"
+        const output = {
+            success: result.success || result.stderr.includes("Booted"),
+            action: "ios_boot_device",
+            udid,
+            error: result.success ? null : result.stderr
+        };
+        await logToolExecution("ios_boot_device", { udid }, output);
+        // Open Simulator.app to see the UI
+        await run(`open -a Simulator`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+        };
+    });
+    // Tool: ios_install_app
+    server.tool("ios_install_app", "Install an .app bundle to a simulator", {
+        udid: z.string().describe("Device UDID"),
+        app_path: z.string().describe("Absolute path to .app bundle"),
+    }, async ({ udid, app_path }) => {
+        const result = await run(`xcrun simctl install ${udid} "${app_path}"`);
+        const output = {
+            success: result.success,
+            action: "ios_install_app",
+            udid,
+            app_path,
+            error: result.error
+        };
+        await logToolExecution("ios_install_app", { udid, app_path }, output);
+        return {
+            content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+        };
+    });
+    // Tool: ios_launch_app
+    server.tool("ios_launch_app", "Launch an installed app on simulator", {
+        udid: z.string().describe("Device UDID"),
+        bundle_id: z.string().describe("App Bundle ID (e.g. com.hashhealth.ios)"),
+    }, async ({ udid, bundle_id }) => {
+        const result = await run(`xcrun simctl launch ${udid} ${bundle_id}`);
+        const output = {
+            success: result.success,
+            action: "ios_launch_app",
+            udid,
+            bundle_id,
+            pid: result.stdout.trim(), // capture PID
+            error: result.error
+        };
+        await logToolExecution("ios_launch_app", { udid, bundle_id }, output);
+        return {
+            content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+        };
+    });
+    // Tool: ios_screenshot
+    server.tool("ios_screenshot", "Take a screenshot of the simulator", {
+        udid: z.string().describe("Device UDID"),
+        filename: z.string().optional().describe("Output filename (default: timestamp)"),
+    }, async ({ udid, filename }) => {
+        const name = filename || `ios_${Date.now()}.png`;
+        const path = join(SCREENSHOT_DIR, name);
+        const result = await run(`xcrun simctl io ${udid} screenshot "${path}"`);
+        const output = {
+            success: result.success,
+            action: "ios_screenshot",
+            udid,
+            path,
+            error: result.error
+        };
+        await logToolExecution("ios_screenshot", { udid, filename }, output);
+        return {
+            content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+        };
+    });
+}

package/dist/utils/exec.d.ts

@@ -18,16 +18,3 @@ export declare function run(command: string, options?: CommandOptions): Promise<
  * Run an ADB command using configured path
  */
 export declare function adb(args: string, options?: CommandOptions): Promise<CommandResult>;
-/**
- * Run a command in the background (detached)
- * Useful for starting the emulator
- */
-export declare function spawnBackground(command: string, args: string[]): Promise<void>;
-/**
- * Run an emulator command using configured path
- */
-export declare function emulator(args: string, options?: CommandOptions): Promise<CommandResult>;
-/**
- * Start the emulator in the background
- */
-export declare function startEmulatorBackground(avdName: string): Promise<void>;