mobile-debug-mcp 0.7.0 → 0.9.0

package/dist/ios/utils.js

@@ -112,3 +112,157 @@ export async function getIOSDeviceMetadata(deviceId = "booted") {
         });
     });
 }
+export async function listIOSDevices(appId) {
+    return new Promise((resolve) => {
+        execFile(XCRUN, ['simctl', 'list', 'devices', '--json'], (err, stdout) => {
+            if (err || !stdout)
+                return resolve([]);
+            try {
+                const data = JSON.parse(stdout);
+                const devicesMap = data.devices || {};
+                const out = [];
+                const checks = [];
+                for (const runtime in devicesMap) {
+                    const devices = devicesMap[runtime];
+                    if (Array.isArray(devices)) {
+                        for (const device of devices) {
+                            const info = {
+                                platform: 'ios',
+                                id: device.udid,
+                                osVersion: parseRuntimeName(runtime),
+                                model: device.name,
+                                simulator: true
+                            };
+                            if (appId) {
+                                // check if installed
+                                const p = execCommand(['simctl', 'get_app_container', device.udid, appId, 'data'], device.udid)
+                                    .then(() => { info.appInstalled = true; })
+                                    .catch(() => { info.appInstalled = false; })
+                                    .then(() => { out.push(info); });
+                                checks.push(p);
+                            }
+                            else {
+                                out.push(info);
+                            }
+                        }
+                    }
+                }
+                Promise.all(checks).then(() => resolve(out)).catch(() => resolve(out));
+            }
+            catch (e) {
+                resolve([]);
+            }
+        });
+    });
+}
+// --- 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, level = 'error', 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 (e) { }
+            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', (code) => {
+            stream.end();
+            iosActiveLogStreams.delete(sessionId);
+        });
+        iosActiveLogStreams.set(sessionId, { proc, file });
+        return { success: true, stream_started: true };
+    }
+    catch (err) {
+        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 (e) { }
+    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 (e) {
+        return { entries: [], crash_summary: { crash_detected: false } };
+    }
+}

package/dist/resolve-device.js

@@ -0,0 +1,70 @@
+import { listAndroidDevices } from "./android/utils.js";
+import { listIOSDevices } from "./ios/utils.js";
+function parseNumericVersion(v) {
+    if (!v)
+        return 0;
+    // extract first number groups like 17.0 -> 17.0 or Android 12 -> 12
+    const m = v.match(/(\d+)(?:[\.\-](\d+))?/);
+    if (!m)
+        return 0;
+    const major = parseInt(m[1], 10) || 0;
+    const minor = parseInt(m[2] || "0", 10) || 0;
+    return major + minor / 100;
+}
+export async function listDevices(platform, appId) {
+    if (!platform || platform === "android") {
+        const android = await listAndroidDevices(appId);
+        if (platform === "android")
+            return android;
+        // if no platform specified, merge with ios below
+        const ios = await listIOSDevices(appId);
+        return [...android, ...ios];
+    }
+    return listIOSDevices(appId);
+}
+export async function resolveTargetDevice(opts) {
+    const { platform, appId, prefer, deviceId } = opts;
+    const devices = await listDevices(platform, appId);
+    if (deviceId) {
+        const found = devices.find(d => d.id === deviceId);
+        if (!found)
+            throw new Error(`Device '${deviceId}' not found for platform ${platform}`);
+        return found;
+    }
+    let candidates = devices.slice();
+    // Apply prefer filter
+    if (prefer === "physical")
+        candidates = candidates.filter(d => !d.simulator);
+    if (prefer === "emulator")
+        candidates = candidates.filter(d => d.simulator);
+    // If appId provided, prefer devices with appInstalled
+    if (appId) {
+        const installed = candidates.filter(d => d.appInstalled);
+        if (installed.length > 0)
+            candidates = installed;
+    }
+    if (candidates.length === 1)
+        return candidates[0];
+    if (candidates.length > 1) {
+        // Prefer physical over emulator unless prefer=emulator
+        if (!prefer) {
+            const physical = candidates.filter(d => !d.simulator);
+            if (physical.length === 1)
+                return physical[0];
+            if (physical.length > 1)
+                candidates = physical;
+        }
+        // Pick highest OS version
+        candidates.sort((a, b) => parseNumericVersion(b.osVersion) - parseNumericVersion(a.osVersion));
+        // If top is unique (numeric differs), return it
+        if (candidates.length > 1 && parseNumericVersion(candidates[0].osVersion) > parseNumericVersion(candidates[1].osVersion)) {
+            return candidates[0];
+        }
+        // Ambiguous: throw an error with candidate list so caller (agent) can present choices
+        const list = candidates.map(d => ({ id: d.id, platform: d.platform, osVersion: d.osVersion, model: d.model, simulator: d.simulator, appInstalled: d.appInstalled }));
+        const err = new Error(`Multiple matching devices found: ${JSON.stringify(list, null, 2)}`);
+        err.devices = list;
+        throw err;
+    }
+    throw new Error(`No devices found for platform ${platform}`);
+}

package/dist/server.js

@@ -6,6 +6,12 @@ import { AndroidObserve } from "./android/observe.js";
 import { AndroidInteract } from "./android/interact.js";
 import { iOSObserve } from "./ios/observe.js";
 import { iOSInteract } from "./ios/interact.js";
+import { installAppHandler } from './tools/install.js';
+import { startAppHandler, terminateAppHandler, restartAppHandler, resetAppDataHandler } from './tools/app.js';
+import { getLogsHandler, startLogStreamHandler, readLogStreamHandler, stopLogStreamHandler } from './tools/logs.js';
+import { listDevicesHandler } from './tools/devices.js';
+import { captureScreenshotHandler } from './tools/screenshot.js';
+import { getUITreeHandler, getCurrentScreenHandler, waitForElementHandler, tapHandler, swipeHandler, typeTextHandler, pressBackHandler } from './tools/ui.js';
 const androidObserve = new AndroidObserve();
 const androidInteract = new AndroidInteract();
 const iosObserve = new iOSObserve();
@@ -116,6 +122,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["platform", "appId"]
             }
         },
+        {
+            name: "install_app",
+            description: "Install an app on Android or iOS. Accepts a built binary (apk/.ipa/.app) or a project directory to build then install.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    platform: { type: "string", enum: ["android", "ios"], description: "Optional. If omitted the server will attempt to detect platform from appPath/project files." },
+                    appPath: { type: "string", description: "Path to APK, .app, .ipa, or project directory" },
+                    deviceId: { type: "string", description: "Device UDID (iOS) or Serial (Android). Defaults to booted/connected." }
+                },
+                required: ["appPath"]
+            }
+        },
         {
             name: "get_logs",
             description: "Get recent logs from Android or iOS simulator. Returns device metadata and the log output.",
@@ -142,6 +161,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["platform"]
             }
         },
+        {
+            name: "list_devices",
+            description: "List connected devices and their metadata (android + ios).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    platform: { type: "string", enum: ["android", "ios"] }
+                }
+            }
+        },
         {
             name: "capture_screenshot",
             description: "Capture a screenshot from an Android device or iOS simulator. Returns device metadata and the screenshot image.",
@@ -160,6 +189,41 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["platform"]
             }
         },
+        {
+            name: "start_log_stream",
+            description: "Start streaming logs for a target application on Android or iOS. For Android this uses adb logcat --pid=<pid>; for iOS it streams `xcrun simctl spawn <device> log stream` with a predicate.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    platform: { type: "string", enum: ["android", "ios"], default: "android" },
+                    packageName: { type: "string", description: "Android package name or iOS bundle id" },
+                    level: { type: "string", enum: ["error", "warn", "info", "debug"], default: "error" },
+                    deviceId: { type: "string", description: "Device Serial (Android) or UDID (iOS). Defaults to connected/booted device." },
+                    sessionId: { type: "string", description: "Session identifier for the log stream" }
+                },
+                required: ["packageName"]
+            }
+        },
+        {
+            name: "read_log_stream",
+            description: "Read accumulated log stream entries for the active session.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: { type: "string" }
+                }
+            }
+        },
+        {
+            name: "stop_log_stream",
+            description: "Stop an active log stream for the session.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: { type: "string" }
+                }
+            }
+        },
         {
             name: "get_ui_tree",
             description: "Get the current UI hierarchy from an Android device or iOS simulator. Returns a structured JSON representation of the screen content.",
@@ -319,249 +383,117 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         if (name === "start_app") {
             const { platform, appId, deviceId } = args;
-            let appStarted;
-            let launchTimeMs;
-            let deviceInfo;
-            if (platform === "android") {
-                const result = await androidInteract.startApp(appId, deviceId);
-                appStarted = result.appStarted;
-                launchTimeMs = result.launchTimeMs;
-                deviceInfo = result.device;
-            }
-            else {
-                const result = await iosInteract.startApp(appId, deviceId);
-                appStarted = result.appStarted;
-                launchTimeMs = result.launchTimeMs;
-                deviceInfo = result.device;
-            }
+            const result = await startAppHandler({ platform, appId, deviceId });
             const response = {
-                device: deviceInfo,
-                appStarted,
-                launchTimeMs
+                device: result.device,
+                appStarted: result.appStarted,
+                launchTimeMs: result.launchTimeMs
             };
             return wrapResponse(response);
         }
         if (name === "terminate_app") {
             const { platform, appId, deviceId } = args;
-            let appTerminated;
-            let deviceInfo;
-            if (platform === "android") {
-                const result = await androidInteract.terminateApp(appId, deviceId);
-                appTerminated = result.appTerminated;
-                deviceInfo = result.device;
-            }
-            else {
-                const result = await iosInteract.terminateApp(appId, deviceId);
-                appTerminated = result.appTerminated;
-                deviceInfo = result.device;
-            }
-            const response = {
-                device: deviceInfo,
-                appTerminated
-            };
+            const result = await terminateAppHandler({ platform, appId, deviceId });
+            const response = { device: result.device, appTerminated: result.appTerminated };
             return wrapResponse(response);
         }
         if (name === "restart_app") {
             const { platform, appId, deviceId } = args;
-            let appRestarted;
-            let launchTimeMs;
-            let deviceInfo;
-            if (platform === "android") {
-                const result = await androidInteract.restartApp(appId, deviceId);
-                appRestarted = result.appRestarted;
-                launchTimeMs = result.launchTimeMs;
-                deviceInfo = result.device;
-            }
-            else {
-                const result = await iosInteract.restartApp(appId, deviceId);
-                appRestarted = result.appRestarted;
-                launchTimeMs = result.launchTimeMs;
-                deviceInfo = result.device;
-            }
-            const response = {
-                device: deviceInfo,
-                appRestarted,
-                launchTimeMs
-            };
+            const result = await restartAppHandler({ platform, appId, deviceId });
+            const response = { device: result.device, appRestarted: result.appRestarted, launchTimeMs: result.launchTimeMs };
             return wrapResponse(response);
         }
         if (name === "reset_app_data") {
             const { platform, appId, deviceId } = args;
-            let dataCleared;
-            let deviceInfo;
-            if (platform === "android") {
-                const result = await androidInteract.resetAppData(appId, deviceId);
-                dataCleared = result.dataCleared;
-                deviceInfo = result.device;
-            }
-            else {
-                const result = await iosInteract.resetAppData(appId, deviceId);
-                dataCleared = result.dataCleared;
-                deviceInfo = result.device;
-            }
+            const result = await resetAppDataHandler({ platform, appId, deviceId });
+            const response = { device: result.device, dataCleared: result.dataCleared };
+            return wrapResponse(response);
+        }
+        if (name === "install_app") {
+            const { platform, appPath, deviceId } = args;
+            const result = await installAppHandler({ platform, appPath, deviceId });
             const response = {
-                device: deviceInfo,
-                dataCleared
+                device: result.device,
+                installed: result.installed,
+                output: result.output,
+                error: result.error
             };
             return wrapResponse(response);
         }
         if (name === "get_logs") {
             const { platform, appId, deviceId, lines } = args;
-            let logs;
-            let deviceInfo;
-            if (platform === "android") {
-                deviceInfo = await androidObserve.getDeviceMetadata(appId || "", deviceId);
-                const response = await androidObserve.getLogs(appId, lines ?? 200, deviceId);
-                logs = Array.isArray(response.logs) ? response.logs : [];
-            }
-            else {
-                deviceInfo = await iosObserve.getDeviceMetadata(deviceId);
-                const response = await iosObserve.getLogs(appId, deviceId);
-                logs = Array.isArray(response.logs) ? response.logs : [];
-            }
-            // Filter crash lines (e.g. lines containing 'FATAL EXCEPTION') for internal or AI use
-            const crashLines = logs.filter(line => line.includes('FATAL EXCEPTION'));
-            // Return device metadata plus logs
+            const res = await getLogsHandler({ platform, appId, deviceId, lines });
             return {
                 content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            device: deviceInfo,
-                            result: {
-                                lines: logs.length,
-                                crashLines: crashLines.length > 0 ? crashLines : undefined
-                            }
-                        }, null, 2)
-                    },
-                    {
-                        type: "text",
-                        text: logs.join("\n")
-                    }
+                    { type: 'text', text: JSON.stringify({ device: res.device, result: { lines: res.logs.length, crashLines: res.crashLines.length > 0 ? res.crashLines : undefined } }, null, 2) },
+                    { type: 'text', text: (res.logs || []).join('\n') }
                 ]
             };
         }
+        if (name === "list_devices") {
+            const { platform, appId } = (args || {});
+            const res = await listDevicesHandler({ platform, appId });
+            return wrapResponse(res);
+        }
         if (name === "capture_screenshot") {
             const { platform, deviceId } = args;
-            let screenshot;
-            let resolution;
-            let deviceInfo;
-            if (platform === "android") {
-                deviceInfo = await androidObserve.getDeviceMetadata("", deviceId);
-                const result = await androidObserve.captureScreen(deviceId);
-                screenshot = result.screenshot;
-                resolution = result.resolution;
-            }
-            else {
-                deviceInfo = await iosObserve.getDeviceMetadata(deviceId);
-                const result = await iosObserve.captureScreenshot(deviceId);
-                screenshot = result.screenshot;
-                resolution = result.resolution;
-            }
+            const res = await captureScreenshotHandler({ platform, deviceId });
             return {
                 content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            device: deviceInfo,
-                            result: {
-                                resolution
-                            }
-                        }, null, 2)
-                    },
-                    {
-                        type: "image",
-                        data: screenshot,
-                        mimeType: "image/png"
-                    }
+                    { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: res.resolution } }, null, 2) },
+                    { type: 'image', data: res.screenshot, mimeType: 'image/png' }
                 ]
             };
         }
         if (name === "get_ui_tree") {
             const { platform, deviceId } = args;
-            let result;
-            if (platform === "android") {
-                result = await androidObserve.getUITree(deviceId);
-            }
-            else if (platform === "ios") {
-                result = await iosObserve.getUITree(deviceId);
-            }
-            else {
-                throw new Error(`Platform ${platform} not supported for get_ui_tree`);
-            }
-            return wrapResponse(result);
+            const res = await getUITreeHandler({ platform, deviceId });
+            return wrapResponse(res);
         }
         if (name === "get_current_screen") {
             const { deviceId } = (args || {});
-            const result = await androidObserve.getCurrentScreen(deviceId);
-            return wrapResponse(result);
+            const res = await getCurrentScreenHandler({ deviceId });
+            return wrapResponse(res);
         }
         if (name === "wait_for_element") {
             const { platform, text, timeout, deviceId } = (args || {});
-            const effectiveTimeout = timeout ?? 10000;
-            let result;
-            if (platform === "android") {
-                result = await androidInteract.waitForElement(text, effectiveTimeout, deviceId);
-            }
-            else {
-                result = await iosInteract.waitForElement(text, effectiveTimeout, deviceId);
-            }
-            return wrapResponse(result);
+            const res = await waitForElementHandler({ platform, text, timeout, deviceId });
+            return wrapResponse(res);
         }
         if (name === "tap") {
             const { platform, x, y, deviceId } = (args || {});
-            const effectivePlatform = platform || "android";
-            // Basic validation
-            if (typeof x !== 'number' || typeof y !== 'number') {
-                throw new Error("x and y coordinates are required and must be numbers");
-            }
-            let result;
-            if (effectivePlatform === "android") {
-                result = await androidInteract.tap(x, y, deviceId);
-            }
-            else {
-                result = await iosInteract.tap(x, y, deviceId);
-            }
-            return wrapResponse(result);
+            const res = await tapHandler({ platform, x, y, deviceId });
+            return wrapResponse(res);
         }
         if (name === "swipe") {
-            const { platform, x1, y1, x2, y2, duration, deviceId } = (args || {});
-            const effectivePlatform = platform || "android";
-            if (typeof x1 !== 'number' || typeof y1 !== 'number' || typeof x2 !== 'number' || typeof y2 !== 'number' || typeof duration !== 'number') {
-                throw new Error("x1, y1, x2, y2, and duration are required and must be numbers");
-            }
-            let result;
-            if (effectivePlatform === "android") {
-                result = await androidInteract.swipe(x1, y1, x2, y2, duration, deviceId);
-            }
-            else {
-                throw new Error(`Platform ${effectivePlatform} not supported for swipe`);
-            }
-            return wrapResponse(result);
+            const { x1, y1, x2, y2, duration, deviceId } = (args || {});
+            const res = await swipeHandler({ x1, y1, x2, y2, duration, deviceId });
+            return wrapResponse(res);
         }
         if (name === "type_text") {
-            const { platform, text, deviceId } = (args || {});
-            const effectivePlatform = platform || "android";
-            if (typeof text !== 'string') {
-                throw new Error("text is required and must be a string");
-            }
-            let result;
-            if (effectivePlatform === "android") {
-                result = await androidInteract.typeText(text, deviceId);
-            }
-            else {
-                throw new Error(`Platform ${effectivePlatform} not supported for type_text`);
-            }
-            return wrapResponse(result);
+            const { text, deviceId } = (args || {});
+            const res = await typeTextHandler({ text, deviceId });
+            return wrapResponse(res);
         }
         if (name === "press_back") {
-            const { platform, deviceId } = (args || {});
-            const effectivePlatform = platform || "android";
-            if (effectivePlatform !== "android") {
-                throw new Error(`Platform ${effectivePlatform} not supported for press_back`);
-            }
-            const result = await androidInteract.pressBack(deviceId);
-            return wrapResponse(result);
+            const { deviceId } = (args || {});
+            const res = await pressBackHandler({ deviceId });
+            return wrapResponse(res);
+        }
+        if (name === 'start_log_stream') {
+            const { platform, packageName, level, sessionId, deviceId } = args;
+            const res = await startLogStreamHandler({ platform, packageName, level, sessionId, deviceId });
+            return wrapResponse(res);
+        }
+        if (name === 'read_log_stream') {
+            const { platform, sessionId, limit, since } = args;
+            const res = await readLogStreamHandler({ platform, sessionId, limit, since });
+            return wrapResponse(res);
+        }
+        if (name === 'stop_log_stream') {
+            const { platform, sessionId } = (args || {});
+            const res = await stopLogStreamHandler({ platform, sessionId });
+            return wrapResponse(res);
         }
     }
     catch (error) {

package/dist/tools/app.js

@@ -0,0 +1,45 @@
+import { resolveTargetDevice } from '../resolve-device.js';
+import { AndroidInteract } from '../android/interact.js';
+import { iOSInteract } from '../ios/interact.js';
+const androidInteract = new AndroidInteract();
+const iosInteract = new iOSInteract();
+export async function startAppHandler({ platform, appId, deviceId }) {
+    if (platform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+        return await androidInteract.startApp(appId, resolved.id);
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+        return await iosInteract.startApp(appId, resolved.id);
+    }
+}
+export async function terminateAppHandler({ platform, appId, deviceId }) {
+    if (platform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+        return await androidInteract.terminateApp(appId, resolved.id);
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+        return await iosInteract.terminateApp(appId, resolved.id);
+    }
+}
+export async function restartAppHandler({ platform, appId, deviceId }) {
+    if (platform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+        return await androidInteract.restartApp(appId, resolved.id);
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+        return await iosInteract.restartApp(appId, resolved.id);
+    }
+}
+export async function resetAppDataHandler({ platform, appId, deviceId }) {
+    if (platform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+        return await androidInteract.resetAppData(appId, resolved.id);
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+        return await iosInteract.resetAppData(appId, resolved.id);
+    }
+}