mobile-debug-mcp 0.10.0 → 0.12.0

package/dist/ios/run.js

@@ -0,0 +1,200 @@
+import { promises as fs } from "fs";
+import { spawn } from "child_process";
+import { execCommand, getIOSDeviceMetadata, validateBundleId, IDB } from "./utils.js";
+import path from "path";
+export class iOSManage {
+    async build(projectPath, _variant) {
+        void _variant;
+        try {
+            async function findAppBundle(dir) {
+                const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+                for (const e of entries) {
+                    const full = path.join(dir, e.name);
+                    if (e.isDirectory()) {
+                        if (full.endsWith('.app'))
+                            return full;
+                        const found = await findAppBundle(full);
+                        if (found)
+                            return found;
+                    }
+                }
+                return undefined;
+            }
+            const files = await fs.readdir(projectPath).catch(() => []);
+            const workspace = files.find(f => f.endsWith('.xcworkspace'));
+            const proj = files.find(f => f.endsWith('.xcodeproj'));
+            if (!workspace && !proj)
+                return { error: 'No Xcode project or workspace found' };
+            let buildArgs;
+            if (workspace) {
+                const workspacePath = path.join(projectPath, workspace);
+                const scheme = workspace.replace(/\.xcworkspace$/, '');
+                buildArgs = ['-workspace', workspacePath, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build'];
+            }
+            else {
+                const projectPathFull = path.join(projectPath, proj);
+                const scheme = proj.replace(/\.xcodeproj$/, '');
+                buildArgs = ['-project', projectPathFull, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build'];
+            }
+            await new Promise((resolve, reject) => {
+                const proc = spawn('xcodebuild', buildArgs, { cwd: projectPath });
+                let stderr = '';
+                proc.stderr?.on('data', d => stderr += d.toString());
+                proc.on('close', code => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(stderr || `xcodebuild failed with code ${code}`));
+                });
+                proc.on('error', err => reject(err));
+            });
+            const built = await findAppBundle(projectPath);
+            if (!built)
+                return { error: 'Could not find .app after build' };
+            return { artifactPath: built };
+        }
+        catch (e) {
+            return { error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    async installApp(appPath, deviceId = "booted") {
+        const device = await getIOSDeviceMetadata(deviceId);
+        async function findAppBundle(dir) {
+            const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+            for (const e of entries) {
+                const full = path.join(dir, e.name);
+                if (e.isDirectory()) {
+                    if (full.endsWith('.app'))
+                        return full;
+                    const found = await findAppBundle(full);
+                    if (found)
+                        return found;
+                }
+            }
+            return undefined;
+        }
+        try {
+            let toInstall = appPath;
+            const stat = await fs.stat(appPath).catch(() => null);
+            if (stat && stat.isDirectory()) {
+                if (appPath.endsWith('.app')) {
+                    toInstall = appPath;
+                }
+                else {
+                    const found = await findAppBundle(appPath);
+                    if (found) {
+                        toInstall = found;
+                    }
+                    else {
+                        const files = await fs.readdir(appPath).catch(() => []);
+                        const workspace = files.find(f => f.endsWith('.xcworkspace'));
+                        const proj = files.find(f => f.endsWith('.xcodeproj'));
+                        if (!workspace && !proj)
+                            throw new Error('No .app bundle, .xcworkspace or .xcodeproj found in directory');
+                        let buildArgs;
+                        if (workspace) {
+                            const workspacePath = path.join(appPath, workspace);
+                            const scheme = workspace.replace(/\.xcworkspace$/, '');
+                            buildArgs = ['-workspace', workspacePath, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build', '-quiet'];
+                        }
+                        else {
+                            const projectPath = path.join(appPath, proj);
+                            const scheme = proj.replace(/\.xcodeproj$/, '');
+                            buildArgs = ['-project', projectPath, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build', '-quiet'];
+                        }
+                        await new Promise((resolve, reject) => {
+                            const proc = spawn('xcodebuild', buildArgs, { cwd: appPath });
+                            let stderr = '';
+                            proc.stderr?.on('data', d => stderr += d.toString());
+                            proc.on('close', code => {
+                                if (code === 0)
+                                    resolve();
+                                else
+                                    reject(new Error(stderr || `xcodebuild failed with code ${code}`));
+                            });
+                            proc.on('error', err => reject(err));
+                        });
+                        const built = await findAppBundle(appPath);
+                        if (!built)
+                            throw new Error('Could not locate built .app after xcodebuild');
+                        toInstall = built;
+                    }
+                }
+            }
+            try {
+                const res = await execCommand(['simctl', 'install', deviceId, toInstall], deviceId);
+                return { device, installed: true, output: res.output };
+            }
+            catch (e) {
+                try {
+                    const child = spawn(IDB, ['--version']);
+                    const idbExists = await new Promise((resolve) => {
+                        child.on('error', () => resolve(false));
+                        child.on('close', (code) => resolve(code === 0));
+                    });
+                    if (idbExists) {
+                        await new Promise((resolve, reject) => {
+                            const proc = spawn(IDB, ['install', toInstall, '--udid', device.id]);
+                            let stderr = '';
+                            proc.stderr.on('data', d => stderr += d.toString());
+                            proc.on('close', code => {
+                                if (code === 0)
+                                    resolve();
+                                else
+                                    reject(new Error(stderr || `idb install failed with code ${code}`));
+                            });
+                            proc.on('error', err => reject(err));
+                        });
+                        return { device, installed: true };
+                    }
+                }
+                catch { }
+                return { device, installed: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        }
+        catch (e) {
+            return { device, installed: false, error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    async startApp(bundleId, deviceId = "booted") {
+        validateBundleId(bundleId);
+        const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId);
+        const device = await getIOSDeviceMetadata(deviceId);
+        return { device, appStarted: !!result.output, launchTimeMs: 1000 };
+    }
+    async terminateApp(bundleId, deviceId = "booted") {
+        validateBundleId(bundleId);
+        await execCommand(['simctl', 'terminate', deviceId, bundleId], deviceId);
+        const device = await getIOSDeviceMetadata(deviceId);
+        return { device, appTerminated: true };
+    }
+    async restartApp(bundleId, deviceId = "booted") {
+        await this.terminateApp(bundleId, deviceId);
+        const startResult = await this.startApp(bundleId, deviceId);
+        return { device: startResult.device, appRestarted: startResult.appStarted, launchTimeMs: startResult.launchTimeMs };
+    }
+    async resetAppData(bundleId, deviceId = "booted") {
+        validateBundleId(bundleId);
+        await this.terminateApp(bundleId, deviceId);
+        const device = await getIOSDeviceMetadata(deviceId);
+        const containerResult = await execCommand(['simctl', 'get_app_container', deviceId, bundleId, 'data'], deviceId);
+        const dataPath = containerResult.output.trim();
+        if (!dataPath)
+            throw new Error(`Could not find data container for ${bundleId}`);
+        try {
+            const libraryPath = `${dataPath}/Library`;
+            const documentsPath = `${dataPath}/Documents`;
+            const tmpPath = `${dataPath}/tmp`;
+            await fs.rm(libraryPath, { recursive: true, force: true }).catch(() => { });
+            await fs.rm(documentsPath, { recursive: true, force: true }).catch(() => { });
+            await fs.rm(tmpPath, { recursive: true, force: true }).catch(() => { });
+            await fs.mkdir(libraryPath, { recursive: true }).catch(() => { });
+            await fs.mkdir(documentsPath, { recursive: true }).catch(() => { });
+            await fs.mkdir(tmpPath, { recursive: true }).catch(() => { });
+            return { device, dataCleared: true };
+        }
+        catch (e) {
+            throw new Error(`Failed to clear data for ${bundleId}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+}

package/dist/ios/utils.js

@@ -1,6 +1,90 @@
-import { execFile, spawn } from "child_process";
-export const XCRUN = process.env.XCRUN_PATH || "xcrun";
-export const IDB = "idb";
+import { execFile, spawn, execSync, spawnSync } from "child_process";
+import { promises as fsPromises } from 'fs';
+import path from 'path';
+import { makeEnvSnapshot } from '../utils/diagnostics.js';
+export function getXcrunCmd() { return process.env.XCRUN_PATH || 'xcrun'; }
+export function getConfiguredIdbPath() {
+    if (process.env.MCP_IDB_PATH)
+        return process.env.MCP_IDB_PATH;
+    if (process.env.IDB_PATH)
+        return process.env.IDB_PATH;
+    const cfgPaths = [
+        process.env.MCP_CONFIG_PATH || (process.env.HOME ? `${process.env.HOME}/.mcp/config.json` : ''),
+        `${process.cwd()}/mcp.config.json`
+    ];
+    try {
+        const fs = require('fs');
+        for (const p of cfgPaths) {
+            if (!p)
+                continue;
+            try {
+                if (fs.existsSync(p)) {
+                    const raw = fs.readFileSync(p, 'utf8');
+                    const json = JSON.parse(raw);
+                    if (json) {
+                        if (json.idbPath)
+                            return json.idbPath;
+                        if (json.IDB_PATH)
+                            return json.IDB_PATH;
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return undefined;
+}
+export function getIdbCmd() {
+    const cfg = getConfiguredIdbPath();
+    if (cfg)
+        return cfg;
+    if (process.env.IDB_PATH)
+        return process.env.IDB_PATH;
+    try {
+        const p = execSync('which idb', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+        if (p)
+            return p;
+    }
+    catch { }
+    try {
+        const p2 = execSync('command -v idb', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+        if (p2)
+            return p2;
+    }
+    catch { }
+    // check common user locations
+    const common = [
+        `${process.env.HOME}/Library/Python/3.9/bin/idb`,
+        `${process.env.HOME}/Library/Python/3.10/bin/idb`,
+        '/opt/homebrew/bin/idb',
+        '/usr/local/bin/idb',
+    ];
+    for (const c of common) {
+        try {
+            execSync(`test -x ${c}`, { stdio: ['ignore', 'pipe', 'ignore'] });
+            return c;
+        }
+        catch { }
+    }
+    return 'idb';
+}
+export async function isIDBInstalled() {
+    const cmd = getIdbCmd();
+    try {
+        execSync(`command -v ${cmd}`, { stdio: ['ignore', 'pipe', 'ignore'] });
+        return true;
+    }
+    catch {
+        try {
+            execSync(`${cmd} list-targets --json`, { stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
 // Validate bundle ID to prevent any potential injection or invalid characters
 export function validateBundleId(bundleId) {
     if (!bundleId)
@@ -13,7 +97,7 @@ export function validateBundleId(bundleId) {
 export function execCommand(args, deviceId = "booted") {
     return new Promise((resolve, reject) => {
         // Use spawn for better stream control and consistency with Android implementation
-        const child = spawn(XCRUN, args);
+        const child = spawn(getXcrunCmd(), args);
         let stdout = '';
         let stderr = '';
         if (child.stdout) {
@@ -26,10 +110,12 @@ export function execCommand(args, deviceId = "booted") {
                 stderr += data.toString();
             });
         }
-        const timeoutMs = args.includes('log') ? 10000 : 5000; // 10s for logs, 5s for others
+        const DEFAULT_XCRUN_LOG_TIMEOUT = parseInt(process.env.MCP_XCRUN_LOG_TIMEOUT || '', 10) || 30000; // env (ms) or default 30s
+        const DEFAULT_XCRUN_CMD_TIMEOUT = parseInt(process.env.MCP_XCRUN_TIMEOUT || '', 10) || 60000; // env (ms) or default 60s
+        const timeoutMs = args.includes('log') ? DEFAULT_XCRUN_LOG_TIMEOUT : DEFAULT_XCRUN_CMD_TIMEOUT; // choose appropriate timeout
         const timeout = setTimeout(() => {
             child.kill();
-            reject(new Error(`Command timed out after ${timeoutMs}ms: ${XCRUN} ${args.join(' ')}`));
+            reject(new Error(`Command timed out after ${timeoutMs}ms: ${getXcrunCmd()} ${args.join(' ')}`));
         }, timeoutMs);
         child.on('close', (code) => {
             clearTimeout(timeout);
@@ -46,6 +132,35 @@ export function execCommand(args, deviceId = "booted") {
         });
     });
 }
+export function execCommandWithDiagnostics(args, deviceId = "booted") {
+    // Run synchronously to capture stdout/stderr and exitCode reliably for diagnostics
+    const DEFAULT_XCRUN_LOG_TIMEOUT = parseInt(process.env.MCP_XCRUN_LOG_TIMEOUT || '', 10) || 30000;
+    const DEFAULT_XCRUN_CMD_TIMEOUT = parseInt(process.env.MCP_XCRUN_TIMEOUT || '', 10) || 60000;
+    const timeoutMs = args.includes('log') ? DEFAULT_XCRUN_LOG_TIMEOUT : DEFAULT_XCRUN_CMD_TIMEOUT;
+    const res = spawnSync(getXcrunCmd(), args, { encoding: 'utf8', timeout: timeoutMs });
+    const runResult = {
+        exitCode: typeof res.status === 'number' ? res.status : null,
+        stdout: res.stdout || '',
+        stderr: res.stderr || '',
+        envSnapshot: makeEnvSnapshot(['PATH', 'IDB_PATH', 'JAVA_HOME', 'HOME']),
+        command: getXcrunCmd(),
+        args,
+        deviceId
+    };
+    if (res.status !== 0) {
+        // include suggested fixes for common errors
+        const suggested = [];
+        if ((runResult.stderr || '').includes('xcodebuild: error')) {
+            suggested.push('Ensure the project/workspace path is correct and xcodebuild is installed and accessible.');
+        }
+        if ((runResult.stderr || '').includes('No such file or directory') || (runResult.stderr || '').includes('not found')) {
+            suggested.push('Check that Xcode Command Line Tools are installed and XCRUN_PATH is set if using non-standard location.');
+        }
+        // Return diagnostics object
+        return { runResult: { ...runResult, suggestedFixes: suggested } };
+    }
+    return { runResult: { ...runResult, suggestedFixes: [] } };
+}
 function parseRuntimeName(runtime) {
     // Example: com.apple.CoreSimulator.SimRuntime.iOS-17-0 -> iOS 17.0
     try {
@@ -65,13 +180,24 @@ function parseRuntimeName(runtime) {
         return runtime;
     }
 }
+export async function findAppBundle(dir) {
+    const entries = await fsPromises.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+            if (full.endsWith('.app'))
+                return full;
+            const found = await findAppBundle(full);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
 export async function getIOSDeviceMetadata(deviceId = "booted") {
     return new Promise((resolve) => {
-        // If deviceId is provided (and not "booted"), we could try to list just that device.
-        // But listing all booted devices is usually fine to find the one we want or just one.
-        // Let's stick to listing all and filtering if needed, or just return basic info if we can't find it.
-        execFile(XCRUN, ['simctl', 'list', 'devices', 'booted', '--json'], (err, stdout) => {
-            // Default fallback
+        // If deviceId is provided (and not "booted"), attempt to find that device among booted simulators.
+        execFile(getXcrunCmd(), ['simctl', 'list', 'devices', 'booted', '--json'], (err, stdout) => {
             const fallback = {
                 platform: "ios",
                 id: deviceId,
@@ -86,7 +212,6 @@ export async function getIOSDeviceMetadata(deviceId = "booted") {
             try {
                 const data = JSON.parse(stdout);
                 const devicesMap = data.devices || {};
-                // Find the device
                 for (const runtime in devicesMap) {
                     const devices = devicesMap[runtime];
                     if (Array.isArray(devices)) {
@@ -114,7 +239,7 @@ export async function getIOSDeviceMetadata(deviceId = "booted") {
 }
 export async function listIOSDevices(appId) {
     return new Promise((resolve) => {
-        execFile(XCRUN, ['simctl', 'list', 'devices', '--json'], (err, stdout) => {
+        execFile(getXcrunCmd(), ['simctl', 'list', 'devices', '--json'], (err, stdout) => {
             if (err || !stdout)
                 return resolve([]);
             try {
@@ -155,114 +280,3 @@ export async function listIOSDevices(appId) {
         });
     });
 }
-// --- iOS live log stream support ---
-import { createWriteStream, promises as fsPromises } from 'fs';
-import path from 'path';
-import { parseLogLine } from '../android/utils.js';
-const iosActiveLogStreams = new Map();
-// Test helpers
-export function _setIOSActiveLogStream(sessionId, file) {
-    iosActiveLogStreams.set(sessionId, { proc: {}, file });
-}
-export function _clearIOSActiveLogStream(sessionId) {
-    iosActiveLogStreams.delete(sessionId);
-}
-export async function startIOSLogStream(bundleId, deviceId = 'booted', sessionId = 'default') {
-    try {
-        // Build predicate to filter by process or subsystem
-        const predicate = `process == "${bundleId}" or subsystem contains "${bundleId}"`;
-        // Prevent multiple streams per session
-        if (iosActiveLogStreams.has(sessionId)) {
-            try {
-                iosActiveLogStreams.get(sessionId).proc.kill();
-            }
-            catch { }
-            iosActiveLogStreams.delete(sessionId);
-        }
-        // Start simctl log stream: xcrun simctl spawn <device> log stream --style syslog --predicate '<predicate>'
-        const args = ['simctl', 'spawn', deviceId, 'log', 'stream', '--style', 'syslog', '--predicate', predicate];
-        const proc = spawn(XCRUN, args);
-        // Prepare output file
-        const tmpDir = process.env.TMPDIR || '/tmp';
-        const file = path.join(tmpDir, `mobile-debug-ios-log-${sessionId}.ndjson`);
-        const stream = createWriteStream(file, { flags: 'a' });
-        proc.stdout.on('data', (chunk) => {
-            const text = chunk.toString();
-            const lines = text.split(/\r?\n/).filter(Boolean);
-            for (const l of lines) {
-                // Try to parse with shared parser; parser may be optimized for Android but extracts exceptions and message
-                const entry = parseLogLine(l);
-                stream.write(JSON.stringify(entry) + '\n');
-            }
-        });
-        proc.stderr.on('data', (chunk) => {
-            const text = chunk.toString();
-            const lines = text.split(/\r?\n/).filter(Boolean);
-            for (const l of lines) {
-                const entry = { timestamp: '', level: 'E', tag: 'xcrun', message: l };
-                stream.write(JSON.stringify(entry) + '\n');
-            }
-        });
-        proc.on('close', () => {
-            stream.end();
-            iosActiveLogStreams.delete(sessionId);
-        });
-        iosActiveLogStreams.set(sessionId, { proc, file });
-        return { success: true, stream_started: true };
-    }
-    catch {
-        return { success: false, error: 'log_stream_start_failed' };
-    }
-}
-export async function stopIOSLogStream(sessionId = 'default') {
-    const entry = iosActiveLogStreams.get(sessionId);
-    if (!entry)
-        return { success: true };
-    try {
-        entry.proc.kill();
-    }
-    catch { }
-    iosActiveLogStreams.delete(sessionId);
-    return { success: true };
-}
-export async function readIOSLogStreamLines(sessionId = 'default', limit = 100, since) {
-    const entry = iosActiveLogStreams.get(sessionId);
-    if (!entry)
-        return { entries: [] };
-    try {
-        const data = await fsPromises.readFile(entry.file, 'utf8').catch(() => '');
-        if (!data)
-            return { entries: [], crash_summary: { crash_detected: false } };
-        const lines = data.split(/\r?\n/).filter(Boolean);
-        const parsed = lines.map(l => {
-            try {
-                return JSON.parse(l);
-            }
-            catch {
-                return { message: l, _iso: null, crash: false };
-            }
-        });
-        // Minimal since filtering if provided
-        let filtered = parsed;
-        if (since) {
-            let sinceMs = null;
-            if (/^\d+$/.test(since))
-                sinceMs = Number(since);
-            else {
-                const sDate = new Date(since);
-                if (!isNaN(sDate.getTime()))
-                    sinceMs = sDate.getTime();
-            }
-            if (sinceMs !== null) {
-                filtered = parsed.filter(p => p._iso && (new Date(p._iso).getTime() >= sinceMs));
-            }
-        }
-        const entries = filtered.slice(-Math.max(0, limit));
-        const crashEntry = entries.find(e => e.crash);
-        const crash_summary = crashEntry ? { crash_detected: true, exception: crashEntry.exception, sample: crashEntry.message } : { crash_detected: false };
-        return { entries, crash_summary };
-    }
-    catch {
-        return { entries: [], crash_summary: { crash_detected: false } };
-    }
-}

package/dist/server.js

@@ -2,12 +2,11 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { ToolsManage } from './tools/manage.js';
 import { ToolsInteract } from './tools/interact.js';
 import { ToolsObserve } from './tools/observe.js';
-import { AndroidInteract } from './android/interact.js';
-import { iOSInteract } from './ios/interact.js';
-import { AndroidObserve } from './android/observe.js';
-import { iOSObserve } from './ios/observe.js';
+import { AndroidManage } from './android/manage.js';
+import { iOSManage } from './ios/manage.js';
 const server = new Server({
     name: "mobile-debug-mcp",
     version: "0.7.0"
@@ -127,6 +126,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["appPath"]
             }
         },
+        {
+            name: "build_app",
+            description: "Build a project for Android or iOS and return the built artifact path. Does not install.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    platform: { type: "string", enum: ["android", "ios"], description: "Optional. If omitted the server will attempt to detect platform from projectPath files." },
+                    projectPath: { type: "string", description: "Path to project directory (contains gradlew or xcodeproj/xcworkspace)" },
+                    variant: { type: "string", description: "Optional build variant (e.g., Debug/Release)" }
+                },
+                required: ["projectPath"]
+            }
+        },
         {
             name: "get_logs",
             description: "Get recent logs from Android or iOS simulator. Returns device metadata and the log output.",
@@ -375,7 +387,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         if (name === "start_app") {
             const { platform, appId, deviceId } = args;
-            const res = await (platform === 'android' ? new AndroidInteract().startApp(appId, deviceId) : new iOSInteract().startApp(appId, deviceId));
+            const res = await (platform === 'android' ? new AndroidManage().startApp(appId, deviceId) : new iOSManage().startApp(appId, deviceId));
             const response = {
                 device: res.device,
                 appStarted: res.appStarted,
@@ -385,25 +397,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         if (name === "terminate_app") {
             const { platform, appId, deviceId } = args;
-            const res = await (platform === 'android' ? new AndroidInteract().terminateApp(appId, deviceId) : new iOSInteract().terminateApp(appId, deviceId));
+            const res = await (platform === 'android' ? new AndroidManage().terminateApp(appId, deviceId) : new iOSManage().terminateApp(appId, deviceId));
             const response = { device: res.device, appTerminated: res.appTerminated };
             return wrapResponse(response);
         }
         if (name === "restart_app") {
             const { platform, appId, deviceId } = args;
-            const res = await (platform === 'android' ? new AndroidInteract().restartApp(appId, deviceId) : new iOSInteract().restartApp(appId, deviceId));
+            const res = await (platform === 'android' ? new AndroidManage().restartApp(appId, deviceId) : new iOSManage().restartApp(appId, deviceId));
             const response = { device: res.device, appRestarted: res.appRestarted, launchTimeMs: res.launchTimeMs };
             return wrapResponse(response);
         }
         if (name === "reset_app_data") {
             const { platform, appId, deviceId } = args;
-            const res = await (platform === 'android' ? new AndroidInteract().resetAppData(appId, deviceId) : new iOSInteract().resetAppData(appId, deviceId));
+            const res = await (platform === 'android' ? new AndroidManage().resetAppData(appId, deviceId) : new iOSManage().resetAppData(appId, deviceId));
             const response = { device: res.device, dataCleared: res.dataCleared };
             return wrapResponse(response);
         }
         if (name === "install_app") {
             const { platform, appPath, deviceId } = args;
-            const res = await ToolsInteract.installAppHandler({ platform, appPath, deviceId });
+            const res = await ToolsManage.installAppHandler({ platform, appPath, deviceId });
             const response = {
                 device: res.device,
                 installed: res.installed,
@@ -412,6 +424,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
             return wrapResponse(response);
         }
+        if (name === "build_app") {
+            const { platform, projectPath, variant } = args;
+            const res = await ToolsManage.buildAppHandler({ platform, projectPath, variant });
+            return wrapResponse(res);
+        }
+        if (name === 'build_and_install') {
+            const { platform, projectPath, deviceId, timeout } = args;
+            const res = await ToolsManage.buildAndInstallHandler({ platform, projectPath, deviceId, timeout });
+            // res: { ndjson, result }
+            return {
+                content: [
+                    { type: 'text', text: res.ndjson },
+                    { type: 'text', text: JSON.stringify(res.result, null, 2) }
+                ]
+            };
+        }
         if (name === "get_logs") {
             const { platform, appId, deviceId, lines } = args;
             const res = await ToolsObserve.getLogsHandler({ platform, appId, deviceId, lines });
@@ -424,7 +452,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         if (name === "list_devices") {
             const { platform, appId } = (args || {});
-            const res = await ToolsObserve.listDevicesHandler({ platform, appId });
+            const res = await ToolsManage.listDevicesHandler({ platform, appId });
             return wrapResponse(res);
         }
         if (name === "capture_screenshot") {
@@ -439,37 +467,37 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         if (name === "get_ui_tree") {
             const { platform, deviceId } = args;
-            const res = await (platform === 'android' ? new AndroidObserve().getUITree(deviceId) : new iOSObserve().getUITree(deviceId));
+            const res = await ToolsObserve.getUITreeHandler({ platform, deviceId });
             return wrapResponse(res);
         }
         if (name === "get_current_screen") {
             const { deviceId } = (args || {});
-            const res = await new AndroidObserve().getCurrentScreen(deviceId);
+            const res = await ToolsObserve.getCurrentScreenHandler({ deviceId });
             return wrapResponse(res);
         }
         if (name === "wait_for_element") {
             const { platform, text, timeout, deviceId } = (args || {});
-            const res = await (platform === 'android' ? new AndroidInteract().waitForElement(text, timeout, deviceId) : new iOSInteract().waitForElement(text, timeout, deviceId));
+            const res = await ToolsInteract.waitForElementHandler({ platform, text, timeout, deviceId });
             return wrapResponse(res);
         }
         if (name === "tap") {
             const { platform, x, y, deviceId } = (args || {});
-            const res = await (platform === 'android' ? new AndroidInteract().tap(x, y, deviceId) : new iOSInteract().tap(x, y, deviceId));
+            const res = await ToolsInteract.tapHandler({ platform, x, y, deviceId });
             return wrapResponse(res);
         }
         if (name === "swipe") {
             const { x1, y1, x2, y2, duration, deviceId } = (args || {});
-            const res = await new AndroidInteract().swipe(x1, y1, x2, y2, duration, deviceId);
+            const res = await ToolsInteract.swipeHandler({ x1, y1, x2, y2, duration, deviceId });
             return wrapResponse(res);
         }
         if (name === "type_text") {
             const { text, deviceId } = (args || {});
-            const res = await new AndroidInteract().typeText(text, deviceId);
+            const res = await ToolsInteract.typeTextHandler({ text, deviceId });
             return wrapResponse(res);
         }
         if (name === "press_back") {
             const { deviceId } = (args || {});
-            const res = await new AndroidInteract().pressBack(deviceId);
+            const res = await ToolsInteract.pressBackHandler({ deviceId });
             return wrapResponse(res);
         }
         if (name === 'start_log_stream') {