mobile-debug-mcp 0.10.0 → 0.11.0

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"
@@ -375,7 +374,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 +384,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 +411,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
             return wrapResponse(response);
         }
+        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 +434,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 +449,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') {

package/dist/tools/interact.js

@@ -1,89 +1,39 @@
-import { promises as fs } from 'fs';
-import path from 'path';
 import { resolveTargetDevice } from '../resolve-device.js';
 import { AndroidInteract } from '../android/interact.js';
 import { iOSInteract } from '../ios/interact.js';
 export class ToolsInteract {
-    static async installAppHandler({ platform, appPath, deviceId }) {
-        let chosenPlatform = platform;
-        try {
-            const stat = await fs.stat(appPath).catch(() => null);
-            if (stat && stat.isDirectory()) {
-                const files = (await fs.readdir(appPath).catch(() => []));
-                if (files.some(f => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace'))) {
-                    chosenPlatform = 'ios';
-                }
-                else if (files.includes('gradlew') || files.includes('build.gradle') || files.includes('settings.gradle') || (files.includes('app') && (await fs.stat(path.join(appPath, 'app')).catch(() => null)))) {
-                    chosenPlatform = 'android';
-                }
-                else {
-                    chosenPlatform = 'android';
-                }
-            }
-            else if (typeof appPath === 'string') {
-                const ext = path.extname(appPath).toLowerCase();
-                if (ext === '.apk')
-                    chosenPlatform = 'android';
-                else if (ext === '.ipa' || ext === '.app')
-                    chosenPlatform = 'ios';
-                else
-                    chosenPlatform = 'android';
-            }
-        }
-        catch {
-            chosenPlatform = 'android';
-        }
-        if (chosenPlatform === 'android') {
+    static async waitForElementHandler({ platform, text, timeout, deviceId }) {
+        const effectiveTimeout = timeout ?? 10000;
+        if (platform === 'android') {
             const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-            const androidInteract = new AndroidInteract();
-            const result = await androidInteract.installApp(appPath, resolved.id);
-            return result;
+            return await new AndroidInteract().waitForElement(text, effectiveTimeout, resolved.id);
         }
         else {
             const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
-            const iosInteract = new iOSInteract();
-            const result = await iosInteract.installApp(appPath, resolved.id);
-            return result;
+            return await new iOSInteract().waitForElement(text, effectiveTimeout, resolved.id);
         }
     }
-    static async startAppHandler({ platform, appId, deviceId }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
-            return await new AndroidInteract().startApp(appId, resolved.id);
+    static async tapHandler({ platform, x, y, deviceId }) {
+        const effectivePlatform = platform || 'android';
+        if (effectivePlatform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+            return await new AndroidInteract().tap(x, y, resolved.id);
         }
         else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
-            return await new iOSInteract().startApp(appId, resolved.id);
+            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+            return await new iOSInteract().tap(x, y, resolved.id);
         }
     }
-    static async terminateAppHandler({ platform, appId, deviceId }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
-            return await new AndroidInteract().terminateApp(appId, resolved.id);
-        }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
-            return await new iOSInteract().terminateApp(appId, resolved.id);
-        }
+    static async swipeHandler({ x1, y1, x2, y2, duration, deviceId }) {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await new AndroidInteract().swipe(x1, y1, x2, y2, duration, resolved.id);
     }
-    static async restartAppHandler({ platform, appId, deviceId }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
-            return await new AndroidInteract().restartApp(appId, resolved.id);
-        }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
-            return await new iOSInteract().restartApp(appId, resolved.id);
-        }
+    static async typeTextHandler({ text, deviceId }) {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await new AndroidInteract().typeText(text, resolved.id);
     }
-    static async resetAppDataHandler({ platform, appId, deviceId }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
-            return await new AndroidInteract().resetAppData(appId, resolved.id);
-        }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
-            return await new iOSInteract().resetAppData(appId, resolved.id);
-        }
+    static async pressBackHandler({ deviceId }) {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await new AndroidInteract().pressBack(resolved.id);
     }
 }

package/dist/tools/manage.js

@@ -0,0 +1,180 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { resolveTargetDevice, listDevices } from '../resolve-device.js';
+import { AndroidManage } from '../android/manage.js';
+import { iOSManage } from '../ios/manage.js';
+export class ToolsManage {
+    static async buildAppHandler({ platform, projectPath, variant }) {
+        // delegate to platform-specific build implementations
+        const chosen = platform || 'android';
+        if (chosen === 'android') {
+            const android = new AndroidManage();
+            const artifact = await android.build(projectPath, variant);
+            return artifact;
+        }
+        else {
+            const ios = new iOSManage();
+            const artifact = await ios.build(projectPath, variant);
+            return artifact;
+        }
+    }
+    static async installAppHandler({ platform, appPath, deviceId }) {
+        let chosenPlatform = platform;
+        try {
+            const stat = await fs.stat(appPath).catch(() => null);
+            if (stat && stat.isDirectory()) {
+                // If the directory itself looks like an .app bundle, treat as iOS
+                if (appPath.endsWith('.app')) {
+                    chosenPlatform = 'ios';
+                }
+                else {
+                    const files = (await fs.readdir(appPath).catch(() => []));
+                    if (files.some(f => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace'))) {
+                        chosenPlatform = 'ios';
+                    }
+                    else if (files.includes('gradlew') || files.includes('build.gradle') || files.includes('settings.gradle') || (files.includes('app') && (await fs.stat(path.join(appPath, 'app')).catch(() => null)))) {
+                        chosenPlatform = 'android';
+                    }
+                    else {
+                        chosenPlatform = 'android';
+                    }
+                }
+            }
+            else if (typeof appPath === 'string') {
+                const ext = path.extname(appPath).toLowerCase();
+                if (ext === '.apk')
+                    chosenPlatform = 'android';
+                else if (ext === '.ipa' || ext === '.app')
+                    chosenPlatform = 'ios';
+                else
+                    chosenPlatform = 'android';
+            }
+        }
+        catch {
+            chosenPlatform = 'android';
+        }
+        if (chosenPlatform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+            const androidRun = new AndroidManage();
+            const result = await androidRun.installApp(appPath, resolved.id);
+            return result;
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+            const iosRun = new iOSManage();
+            const result = await iosRun.installApp(appPath, resolved.id);
+            return result;
+        }
+    }
+    static async startAppHandler({ platform, appId, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+            return await new AndroidManage().startApp(appId, resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+            return await new iOSManage().startApp(appId, resolved.id);
+        }
+    }
+    static async terminateAppHandler({ platform, appId, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+            return await new AndroidManage().terminateApp(appId, resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+            return await new iOSManage().terminateApp(appId, resolved.id);
+        }
+    }
+    static async restartAppHandler({ platform, appId, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+            return await new AndroidManage().restartApp(appId, resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+            return await new iOSManage().restartApp(appId, resolved.id);
+        }
+    }
+    static async resetAppDataHandler({ platform, appId, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+            return await new AndroidManage().resetAppData(appId, resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+            return await new iOSManage().resetAppData(appId, resolved.id);
+        }
+    }
+    static async buildAndInstallHandler({ platform, projectPath, deviceId, timeout }) {
+        const events = [];
+        const pushEvent = (obj) => events.push(JSON.stringify(obj));
+        const effectiveTimeout = timeout ?? 180000; // reserved for future streaming/timeouts
+        void effectiveTimeout;
+        // determine platform if not provided by inspecting path
+        let chosenPlatform = platform;
+        try {
+            const stat = await fs.stat(projectPath).catch(() => null);
+            if (!chosenPlatform) {
+                if (stat && stat.isDirectory()) {
+                    const files = (await fs.readdir(projectPath).catch(() => []));
+                    if (files.some(f => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace')))
+                        chosenPlatform = 'ios';
+                    else
+                        chosenPlatform = 'android';
+                }
+                else {
+                    const ext = path.extname(projectPath).toLowerCase();
+                    if (ext === '.apk')
+                        chosenPlatform = 'android';
+                    else if (ext === '.ipa' || ext === '.app')
+                        chosenPlatform = 'ios';
+                    else
+                        chosenPlatform = 'android';
+                }
+            }
+        }
+        catch {
+            chosenPlatform = chosenPlatform || 'android';
+        }
+        pushEvent({ type: 'build', status: 'started', platform: chosenPlatform });
+        let buildRes;
+        try {
+            buildRes = await ToolsManage.buildAppHandler({ platform: chosenPlatform, projectPath });
+            if (buildRes && buildRes.error) {
+                pushEvent({ type: 'build', status: 'failed', error: buildRes.error });
+                return { ndjson: events.join('\n') + '\n', result: { success: false, error: buildRes.error } };
+            }
+            pushEvent({ type: 'build', status: 'finished', artifactPath: buildRes.artifactPath });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            pushEvent({ type: 'build', status: 'failed', error: msg });
+            return { ndjson: events.join('\n') + '\n', result: { success: false, error: msg } };
+        }
+        // Install phase
+        const artifact = buildRes.artifactPath || projectPath;
+        pushEvent({ type: 'install', status: 'started', artifactPath: artifact, deviceId });
+        let installRes;
+        try {
+            installRes = await ToolsManage.installAppHandler({ platform: chosenPlatform, appPath: artifact, deviceId });
+            if (installRes && installRes.installed === true) {
+                pushEvent({ type: 'install', status: 'finished', artifactPath: artifact, device: installRes.device });
+                return { ndjson: events.join('\n') + '\n', result: { success: true, artifactPath: artifact, device: installRes.device, output: installRes.output } };
+            }
+            else {
+                pushEvent({ type: 'install', status: 'failed', error: installRes.error || 'unknown' });
+                return { ndjson: events.join('\n') + '\n', result: { success: false, error: installRes.error || 'install failed' } };
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            pushEvent({ type: 'install', status: 'failed', error: msg });
+            return { ndjson: events.join('\n') + '\n', result: { success: false, error: msg } };
+        }
+    }
+    static async listDevicesHandler({ platform, appId }) {
+        const devices = await listDevices(platform, appId);
+        return { devices };
+    }
+}

package/dist/tools/observe.js

@@ -1,9 +1,21 @@
-import { resolveTargetDevice, listDevices } from '../resolve-device.js';
+import { resolveTargetDevice } from '../resolve-device.js';
 import { AndroidObserve } from '../android/observe.js';
 import { iOSObserve } from '../ios/observe.js';
-import { AndroidInteract } from '../android/interact.js';
-import { iOSInteract } from '../ios/interact.js';
 export class ToolsObserve {
+    static async getUITreeHandler({ platform, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+            return await new AndroidObserve().getUITree(resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+            return await new iOSObserve().getUITree(resolved.id);
+        }
+    }
+    static async getCurrentScreenHandler({ deviceId }) {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await new AndroidObserve().getCurrentScreen(resolved.id);
+    }
     static async getLogsHandler({ platform, appId, deviceId, lines }) {
         if (platform === 'android') {
             const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
@@ -25,93 +37,35 @@ export class ToolsObserve {
         const sid = sessionId || 'default';
         if (effectivePlatform === 'android') {
             const resolved = await resolveTargetDevice({ platform: 'android', appId: packageName, deviceId });
-            // AndroidObserve uses utils for log stream control; delegate to android/utils functions where appropriate
-            const { startAndroidLogStream } = await import('../android/utils.js');
-            return await startAndroidLogStream(packageName, level || 'error', resolved.id, sid);
+            // Delegate to AndroidObserve's log stream methods
+            return await new AndroidObserve().startLogStream(packageName, level || 'error', resolved.id, sid);
         }
         else {
             const resolved = await resolveTargetDevice({ platform: 'ios', appId: packageName, deviceId });
-            // iOSObserve implements startIOSLogStream via ios/utils; use its helper
-            const { startIOSLogStream } = await import('../ios/utils.js');
-            return await startIOSLogStream(packageName, resolved.id, sid);
+            // Delegate to iOSObserve for starting log streams
+            return await new iOSObserve().startLogStream(packageName, resolved.id, sid);
         }
     }
     static async readLogStreamHandler({ platform, sessionId, limit, since }) {
         const effectivePlatform = platform || 'android';
         const sid = sessionId || 'default';
         if (effectivePlatform === 'android') {
-            const { readLogStreamLines } = await import('../android/utils.js');
-            return await readLogStreamLines(sid, limit ?? 100, since);
+            return await new AndroidObserve().readLogStream(sid, limit ?? 100, since);
         }
         else {
-            const { readIOSLogStreamLines } = await import('../ios/utils.js');
-            return await readIOSLogStreamLines(sid, limit ?? 100, since);
+            return await new iOSObserve().readLogStream(sid, limit ?? 100, since);
         }
     }
     static async stopLogStreamHandler({ platform, sessionId }) {
         const effectivePlatform = platform || 'android';
         const sid = sessionId || 'default';
         if (effectivePlatform === 'android') {
-            const { stopAndroidLogStream } = await import('../android/utils.js');
-            return await stopAndroidLogStream(sid);
-        }
-        else {
-            const { stopIOSLogStream } = await import('../ios/utils.js');
-            return await stopIOSLogStream(sid);
-        }
-    }
-    static async getUITreeHandler({ platform, deviceId }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-            return await new AndroidObserve().getUITree(resolved.id);
-        }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
-            return await new iOSObserve().getUITree(resolved.id);
-        }
-    }
-    static async getCurrentScreenHandler({ deviceId }) {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-        return await new AndroidObserve().getCurrentScreen(resolved.id);
-    }
-    static async waitForElementHandler({ platform, text, timeout, deviceId }) {
-        const effectiveTimeout = timeout ?? 10000;
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-            return await new AndroidInteract().waitForElement(text, effectiveTimeout, resolved.id);
-        }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
-            return await new iOSInteract().waitForElement(text, effectiveTimeout, resolved.id);
-        }
-    }
-    static async tapHandler({ platform, x, y, deviceId }) {
-        const effectivePlatform = platform || 'android';
-        if (effectivePlatform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-            return await new AndroidInteract().tap(x, y, resolved.id);
+            return await new AndroidObserve().stopLogStream(sid);
         }
         else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
-            return await new iOSInteract().tap(x, y, resolved.id);
+            return await new iOSObserve().stopLogStream(sid);
         }
     }
-    static async swipeHandler({ x1, y1, x2, y2, duration, deviceId }) {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-        return await new AndroidInteract().swipe(x1, y1, x2, y2, duration, resolved.id);
-    }
-    static async typeTextHandler({ text, deviceId }) {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-        return await new AndroidInteract().typeText(text, resolved.id);
-    }
-    static async pressBackHandler({ deviceId }) {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-        return await new AndroidInteract().pressBack(resolved.id);
-    }
-    static async listDevicesHandler({ platform, appId }) {
-        const devices = await listDevices(platform, appId);
-        return { devices };
-    }
     static async captureScreenshotHandler({ platform, deviceId }) {
         const effectivePlatform = platform || 'android';
         if (effectivePlatform === 'android') {