mobile-debug-mcp 0.7.0 → 0.9.0

package/dist/tools/devices.js

@@ -0,0 +1,5 @@
+import { listDevices } from '../resolve-device.js';
+export async function listDevicesHandler({ platform, appId }) {
+    const devices = await listDevices(platform, appId);
+    return { devices };
+}

package/dist/tools/install.js

@@ -0,0 +1,47 @@
+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';
+const androidInteract = new AndroidInteract();
+const iosInteract = new iOSInteract();
+export async function 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 (e) {
+        chosenPlatform = 'android';
+    }
+    if (chosenPlatform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        const result = await androidInteract.installApp(appPath, resolved.id);
+        return result;
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+        const result = await iosInteract.installApp(appPath, resolved.id);
+        return result;
+    }
+}

package/dist/tools/logs.js

@@ -0,0 +1,62 @@
+import { resolveTargetDevice } from '../resolve-device.js';
+import { AndroidObserve } from '../android/observe.js';
+import { iOSObserve } from '../ios/observe.js';
+import { startAndroidLogStream, readLogStreamLines, stopAndroidLogStream } from '../android/utils.js';
+import { startIOSLogStream, readIOSLogStreamLines, stopIOSLogStream } from '../ios/utils.js';
+const androidObserve = new AndroidObserve();
+export async function getLogsHandler({ platform, appId, deviceId, lines }) {
+    if (platform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+        const deviceInfo = resolved;
+        const response = await androidObserve.getLogs(appId, lines ?? 200, resolved.id);
+        const logs = Array.isArray(response.logs) ? response.logs : [];
+        const crashLines = logs.filter(line => line.includes('FATAL EXCEPTION'));
+        return { device: deviceInfo, logs, crashLines };
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+        const deviceInfo = resolved;
+        try {
+            const iosObs = new iOSObserve();
+            const resp = await iosObs.getLogs(appId, resolved.id);
+            const logs = Array.isArray(resp.logs) ? resp.logs : [];
+            const crashLines = logs.filter(l => l.includes('FATAL EXCEPTION'));
+            return { device: deviceInfo, logs, crashLines };
+        }
+        catch (e) {
+            return { device: deviceInfo, logs: [], crashLines: [] };
+        }
+    }
+}
+export async function startLogStreamHandler({ platform, packageName, level, sessionId, deviceId }) {
+    const effectivePlatform = platform || 'android';
+    const sid = sessionId || 'default';
+    if (effectivePlatform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', appId: packageName, deviceId });
+        return await startAndroidLogStream(packageName, level || 'error', resolved.id, sid);
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', appId: packageName, deviceId });
+        return await startIOSLogStream(packageName, level || 'error', resolved.id, sid);
+    }
+}
+export async function readLogStreamHandler({ platform, sessionId, limit, since }) {
+    const effectivePlatform = platform || 'android';
+    const sid = sessionId || 'default';
+    if (effectivePlatform === 'android') {
+        return await readLogStreamLines(sid, limit ?? 100, since);
+    }
+    else {
+        return await readIOSLogStreamLines(sid, limit ?? 100, since);
+    }
+}
+export async function stopLogStreamHandler({ platform, sessionId }) {
+    const effectivePlatform = platform || 'android';
+    const sid = sessionId || 'default';
+    if (effectivePlatform === 'android') {
+        return await stopAndroidLogStream(sid);
+    }
+    else {
+        return await stopIOSLogStream(sid);
+    }
+}

package/dist/tools/screenshot.js

@@ -0,0 +1,17 @@
+import { resolveTargetDevice } from '../resolve-device.js';
+import { AndroidObserve } from '../android/observe.js';
+import { iOSObserve } from '../ios/observe.js';
+const androidObserve = new AndroidObserve();
+const iosObserve = new iOSObserve();
+export async function captureScreenshotHandler({ platform, deviceId }) {
+    if (platform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        const result = await androidObserve.captureScreen(resolved.id);
+        return { device: resolved, resolution: result.resolution, screenshot: result.screenshot };
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+        const result = await iosObserve.captureScreenshot(resolved.id);
+        return { device: resolved, resolution: result.resolution, screenshot: result.screenshot };
+    }
+}

package/dist/tools/ui.js

@@ -0,0 +1,57 @@
+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';
+const androidObserve = new AndroidObserve();
+const iosObserve = new iOSObserve();
+const androidInteract = new AndroidInteract();
+const iosInteract = new iOSInteract();
+export async function getUITreeHandler({ platform, deviceId }) {
+    if (platform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await androidObserve.getUITree(resolved.id);
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+        return await iosObserve.getUITree(resolved.id);
+    }
+}
+export async function getCurrentScreenHandler({ deviceId }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+    return await androidObserve.getCurrentScreen(resolved.id);
+}
+export async function waitForElementHandler({ platform, text, timeout, deviceId }) {
+    const effectiveTimeout = timeout ?? 10000;
+    if (platform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await androidInteract.waitForElement(text, effectiveTimeout, resolved.id);
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+        return await iosInteract.waitForElement(text, effectiveTimeout, resolved.id);
+    }
+}
+export async function tapHandler({ platform, x, y, deviceId }) {
+    const effectivePlatform = platform || 'android';
+    if (effectivePlatform === 'android') {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await androidInteract.tap(x, y, resolved.id);
+    }
+    else {
+        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+        return await iosInteract.tap(x, y, resolved.id);
+    }
+}
+export async function swipeHandler({ x1, y1, x2, y2, duration, deviceId }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+    return await androidInteract.swipe(x1, y1, x2, y2, duration, resolved.id);
+}
+export async function typeTextHandler({ text, deviceId }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+    return await androidInteract.typeText(text, resolved.id);
+}
+export async function pressBackHandler({ deviceId }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+    return await androidInteract.pressBack(resolved.id);
+}

package/docs/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
+## [0.9.0] - 2026-03-14
+
+### Added / Changed
+- install_app now builds apps when given a project directory and then installs the produced artifact (Android: Gradle wrapper assembleDebug; iOS: xcodebuild where applicable).
+- Auto-detects and prefers JDK 17 (Android Studio JBR or system JDK). Any JAVA_HOME overrides are scoped to the spawned build process, avoiding global system changes.
+- Respects ADB_PATH and falls back to PATH if unset. Set ADB_PATH to an explicit adb binary to avoid PATH discovery issues.
+- Increased default adb timeout to 120s for installs; timeout can be configured via MCP_ADB_TIMEOUT or ADB_TIMEOUT environment variables.
+- Improved logging and error messages for build/install steps. Unit and integration tests updated and converted to TypeScript.
+
+## [0.8.0]
+
+### Added
+- **`list_devices` tool**: enumerate connected Android devices and iOS simulators. Returns device metadata (id, platform, osVersion, model, simulator, appInstalled).
+- **`install_app` tool**: install an APK (.apk) on Android or an app bundle (.app/.ipa) on iOS simulators/devices. Uses `adb install -r` for Android and `simctl`/`idb` for iOS.
+- **`start_log_stream`, `read_log_stream`, `stop_log_stream` tools**: stream Android logcat filtered by application PID, poll parsed entries, support incremental reads (limit/since) and basic crash detection metadata (crash_detected, exception, sample).
+
+### Changed
+- Device-selection: server handlers now use a central resolver to pick a sensible default device when `deviceId` is omitted. This reduces duplication and makes behavior deterministic when multiple devices are attached.
+
 ## [0.7.0]
 
 ### Added

package/docs/TOOLS.md

@@ -0,0 +1,272 @@
+# Tools
+
+This document contains detailed definitions for each MCP tool implemented by Mobile Debug MCP. These were extracted from the README to keep the top-level README concise.
+
+Each tool returns a JSON metadata block and, where applicable, additional content blocks (e.g., image data or raw logs). Where an example previously used `jsonc` fences with inline comments, the examples below use `json` fences and external explanatory notes to avoid highlighting issues.
+
+---
+
+## list_devices
+Enumerate connected Android devices and iOS simulators.
+
+Input (optional):
+```json
+{ "platform": "android" | "ios" }
+```
+
+Response:
+```json
+{ "devices": [ { "id": "emulator-5554", "platform": "android", "osVersion": "11", "model": "sdk_gphone64_arm64", "simulator": true, "appInstalled": false } ] }
+```
+
+Notes:
+- Use `list_devices` to inspect connected targets and their metadata. When multiple devices are attached, pass `deviceId` to other tools to target a specific device.
+
+---
+
+## install_app
+Install an app onto a connected device or simulator (APK for Android, .app/.ipa for iOS).
+
+Input:
+```json
+{
+  "platform": "android" | "ios",
+  "appPath": "/path/to/app.apk_or_app.app_or_ipa",
+  "deviceId": "emulator-5554"
+}
+```
+
+Response:
+```json
+{
+  "device": { /* device info */ },
+  "installed": true,
+  "output": "Platform-specific installer output (adb/simctl/idb)",
+  "error": "Optional error message if installation failed"
+}
+```
+
+Notes:
+- Android: the tool attempts to locate and install the APK. If `appPath` points at a project directory, the tool will attempt to run the Gradle wrapper (`./gradlew assembleDebug`) and locate the built APK under `build/outputs/apk/`.
+- The installer respects `ADB_PATH` (preferred) falling back to `adb` on PATH. To avoid PATH discovery issues, set `ADB_PATH` to the full adb binary path.
+- The default ADB command timeout was increased to 120s to handle larger streamed installs. Configure via `MCP_ADB_TIMEOUT` or `ADB_TIMEOUT` env vars.
+- iOS: prefers `xcrun simctl install` for simulators and falls back to `idb install` for devices when available.
+
+---
+
+## start_app
+Launch a mobile app.
+
+Input:
+```json
+{
+  "platform": "android" | "ios",
+  "appId": "com.example.app",
+  "deviceId": "emulator-5554"
+}
+```
+
+Response:
+```json
+{
+  "device": { /* device info */ },
+  "appStarted": true,
+  "launchTimeMs": 123
+}
+```
+
+Notes:
+- Android: uses `adb shell monkey -p <package> -c android.intent.category.LAUNCHER 1` to trigger a launch.
+- iOS: uses `xcrun simctl launch` for simulators or `idb` for devices when available.
+
+---
+
+## get_logs
+Fetch recent logs from the app or device.
+
+Input:
+```json
+{
+  "platform": "android" | "ios",
+  "appId": "com.example.app",
+  "deviceId": "emulator-5554",
+  "lines": 200
+}
+```
+
+Response:
+- The tool returns two content blocks for Android: a JSON metadata block and a plain text log output block. The JSON metadata includes parsed results (counts, crash summaries) and the raw log is provided for inspection.
+
+Notes:
+- Android log parsing is heuristic and includes basic crash detection (searching for "FATAL EXCEPTION" and exception names).
+- Use `lines` to control how many log lines are returned from `adb logcat`.
+
+---
+
+## capture_screenshot
+Capture a screenshot of the current device screen.
+
+Input:
+```json
+{
+  "platform": "android" | "ios",
+  "deviceId": "emulator-5554"
+}
+```
+
+Response:
+- JSON metadata block with resolution and device info, followed by an image/png block containing base64-encoded PNG bytes.
+
+Notes:
+- Android: uses `adb exec-out screencap -p` and returns PNG bytes.
+- iOS: uses `xcrun simctl io booted screenshot` or `idb` capture when available.
+
+---
+
+## terminate_app
+Terminate a running app.
+
+Input:
+```json
+{
+  "platform": "android" | "ios",
+  "appId": "com.example.app",
+  "deviceId": "emulator-5554"
+}
+```
+
+Response:
+```json
+{ "device": { /* device info */ }, "appTerminated": true }
+```
+
+Notes:
+- Android: uses `adb shell am force-stop <package>`.
+
+---
+
+## restart_app
+Restart an app (terminate then launch).
+
+Input/Response: combination of terminate + start as above. Response includes launch timing metadata.
+
+---
+
+## reset_app_data
+Clear app storage (reset to fresh install state).
+
+Input:
+```json
+{
+  "platform": "android" | "ios",
+  "appId": "com.example.app",
+  "deviceId": "emulator-5554"
+}
+```
+
+Response:
+```json
+{ "device": { /* device info */ }, "dataCleared": true }
+```
+
+Notes:
+- Android: uses `adb shell pm clear <package>` and returns whether the operation succeeded.
+
+---
+
+## start_log_stream / read_log_stream / stop_log_stream
+Start a live log stream (background) for an Android app and poll the accumulated entries.
+
+- start_log_stream starts a background `adb logcat` filtered by the app PID and writes parsed NDJSON to a per-session file. Returns immediately with session details.
+- read_log_stream retrieves recent parsed entries and includes crash detection metadata.
+- stop_log_stream terminates the background process and closes the stream.
+
+Input (start_log_stream):
+```json
+{ "packageName": "com.example.app", "level": "error" | "warn" | "info" | "debug", "sessionId": "optional-session-id" }
+```
+
+Response (read_log_stream):
+```json
+{ "entries": [ /* parsed entries */ ], "crash_summary": { "crash_detected": true/false, "exception": "..." } }
+```
+
+Notes:
+- The `since` parameter for read_log_stream accepts ISO timestamps or epoch ms. Use it for incremental polling.
+- Crash detection is heuristic-based and intended as a quick signal for agents.
+
+---
+
+## get_ui_tree
+Get the current UI hierarchy from the device.
+
+Input:
+```json
+{ "platform": "android" | "ios", "deviceId": "emulator-5554" }
+```
+
+Response:
+- Structured JSON containing screen metadata and an array of UI elements with properties: text, contentDescription, type, resourceId, clickable, enabled, visible, bounds, center, depth, parentId, children.
+
+Notes:
+- Android: uses `uiautomator dump` or `adb exec-out uiautomator` fallback methods. Times out on slow responses; use provided timeouts.
+- iOS: uses `idb` or accessibility APIs when available.
+
+---
+
+## get_current_screen
+Get the currently visible activity on Android.
+
+Input:
+```json
+{ "deviceId": "emulator-5554" }
+```
+
+Response:
+```json
+{ "device": { /* device info */ }, "package": "com.example.app", "activity": "com.example.app.LoginActivity", "shortActivity": "LoginActivity" }
+```
+
+Notes:
+- Uses `dumpsys activity activities` and robust parsing to support multiple Android versions.
+
+---
+
+## wait_for_element
+Wait until a UI element with matching text appears on screen or timeout is reached.
+
+Input:
+```json
+{ "platform": "android" | "ios", "text": "Home", "timeout": 5000, "deviceId": "emulator-5554" }
+```
+
+Response:
+```json
+{ "device": { /* device info */ }, "found": true/false, "element": { /* element */ } }
+```
+
+Notes:
+- Polls get_ui_tree until timeout or element found. Returns an `error` field if system failures occur.
+
+---
+
+## tap / swipe / type_text / press_back
+
+- tap: `adb shell input tap x y` (Android) or `idb` events for iOS.
+- swipe: `adb shell input swipe x1 y1 x2 y2 duration`.
+- type_text: `adb shell input text` (spaces encoded as %s) — may fail for special characters.
+- press_back: `adb shell input keyevent 4`.
+
+Inputs and responses follow the device+success pattern used across other tools.
+
+---
+
+## Notes on environment and timeout behavior
+
+- The tools prefer explicit env vars: `ADB_PATH` and `XCRUN_PATH` to locate platform binaries. If unset, tools fall back to PATH lookup.
+- For Android builds, the install tool auto-detects a suitable Java 17 installation (Android Studio JBR or system JDK 17). Any JAVA_HOME overrides are scoped to the spawned Gradle process.
+- Default ADB timeout is now 120s for long operations; override via `MCP_ADB_TIMEOUT` or `ADB_TIMEOUT`.
+
+---
+
+If you need the tools split into per-tool markdown files (e.g., docs/tools/install.md), say so and I will split them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-debug-mcp",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {
@@ -9,7 +9,10 @@
   "scripts": {
     "build": "tsc",
     "start": "node ./dist/server.js",
-    "prepare": "npm run build"
+    "prepare": "npm run build",
+    "test:unit": "tsx test/unit/index.ts",
+    "test:integration": "tsx test/integration/index.ts",
+    "test": "npm run test:unit && npm run test:integration"
   },
   "engines": {
     "node": ">=18"
@@ -21,6 +24,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.4.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }
 }

package/src/android/interact.ts

@@ -1,6 +1,11 @@
 import { StartAppResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse, WaitForElementResponse, TapResponse, SwipeResponse, TypeTextResponse, PressBackResponse } from "../types.js"
-import { execAdb, getAndroidDeviceMetadata, getDeviceInfo } from "./utils.js"
+import { execAdb, getAndroidDeviceMetadata, getDeviceInfo, detectJavaHome } from "./utils.js"
 import { AndroidObserve } from "./observe.js"
+import { promises as fs } from "fs"
+import { spawn, execSync } from "child_process"
+import path from "path"
+import { existsSync } from "fs"
+
 
 export class AndroidInteract {
   private observe = new AndroidObserve();
@@ -87,6 +92,100 @@ export class AndroidInteract {
     }
   }
 
+  async installApp(apkPath: string, deviceId?: string): Promise<import("../types.js").InstallAppResponse> {
+    const metadata = await getAndroidDeviceMetadata("", deviceId)
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
+
+    // Helper to recursively find first APK under a directory
+    async function findApk(dir: string): Promise<string | undefined> {
+      const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => [])
+      for (const e of entries) {
+        const full = path.join(dir, e.name)
+        if (e.isDirectory()) {
+          const found = await findApk(full)
+          if (found) return found
+        } else if (e.isFile() && full.endsWith('.apk')) {
+          return full
+        }
+      }
+      return undefined
+    }
+
+    try {
+      let apkToInstall = apkPath
+
+      // If a directory is provided, attempt to build via Gradle
+      const stat = await fs.stat(apkPath).catch(() => null)
+      if (stat && stat.isDirectory()) {
+        const gradlewPath = path.join(apkPath, 'gradlew')
+        const gradleCmd = existsSync(gradlewPath) ? './gradlew' : 'gradle'
+
+        await new Promise<void>(async (resolve, reject) => {
+          // Auto-detect and set JAVA_HOME (prefer JDK 17) so builds don't require manual environment setup
+          const detectedJavaHome = await detectJavaHome().catch(() => undefined)
+          const env = Object.assign({}, process.env)
+          if (detectedJavaHome) {
+            // Override existing JAVA_HOME if detection found a preferably compatible JDK (e.g., JDK 17).
+            if (env.JAVA_HOME !== detectedJavaHome) {
+              env.JAVA_HOME = detectedJavaHome
+              // Also ensure the JDK bin is on PATH so tools like jlink/javac are resolved from the detected JDK
+              env.PATH = `${path.join(detectedJavaHome, 'bin')}${path.delimiter}${env.PATH || ''}`
+              console.debug('[android] Overriding JAVA_HOME with detected path:', detectedJavaHome)
+            }
+          }
+
+          // Sanitize environment so user shell init scripts are less likely to override our JAVA_HOME.
+          try {
+            // Remove obvious shell profile hints; avoid touching SDKMAN symlinks or on-disk state.
+            delete env.SHELL
+          } catch (e) {}
+
+          // If we detected a compatible JDK, instruct Gradle to use it and avoid daemon reuse
+          // Prepare gradle invocation
+          const gradleArgs = ['assembleDebug']
+          if (detectedJavaHome) {
+            gradleArgs.push(`-Dorg.gradle.java.home=${detectedJavaHome}`)
+            gradleArgs.push('--no-daemon')
+            env.GRADLE_JAVA_HOME = detectedJavaHome
+          }
+
+          // Prefer invoking the wrapper directly without a shell to avoid user profile shims (sdkman) re-setting JAVA_HOME
+          const wrapperPath = path.join(apkPath, 'gradlew')
+          const useWrapper = existsSync(wrapperPath)
+          const execCmd = useWrapper ? wrapperPath : gradleCmd
+          const spawnOpts: any = { cwd: apkPath, env }
+          // When using wrapper, ensure it's executable and invoke directly (no shell)
+          if (useWrapper) {
+            // Ensure the wrapper is executable; swallow errors from chmod (best-effort).
+            await fs.chmod(wrapperPath, 0o755).catch(() => {})
+            spawnOpts.shell = false
+          } else {
+            // if using system 'gradle' allow shell to resolve platform PATH
+            spawnOpts.shell = true
+          }
+
+          const proc = spawn(execCmd, gradleArgs, spawnOpts)
+          let stderr = ''
+          proc.stderr?.on('data', d => stderr += d.toString())
+          proc.on('close', code => {
+            if (code === 0) resolve()
+            else reject(new Error(stderr || `Gradle build failed with code ${code}`))
+          })
+          proc.on('error', err => reject(err))
+        })
+
+        const built = await findApk(apkPath)
+        if (!built) throw new Error('Could not locate built APK after running Gradle')
+        apkToInstall = built
+      }
+
+      const output = await execAdb(['install', '-r', apkToInstall], deviceId)
+      return { device: deviceInfo, installed: true, output }
+    } catch (e) {
+      return { device: deviceInfo, installed: false, error: e instanceof Error ? e.message : String(e) }
+    }
+  }
+
   async startApp(appId: string, deviceId?: string): Promise<StartAppResponse> {
     const metadata = await getAndroidDeviceMetadata(appId, deviceId)
     const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)