mobile-debug-mcp 0.9.0 → 0.10.0

package/src/server.ts

@@ -8,40 +8,19 @@ import {
 
 import {
   StartAppResponse,
-  DeviceInfo,
   TerminateAppResponse,
   RestartAppResponse,
   ResetAppDataResponse,
-  GetUITreeResponse,
-  GetCurrentScreenResponse,
-  WaitForElementResponse,
-  TapResponse,
-  SwipeResponse,
-  TypeTextResponse,
-  PressBackResponse,
   InstallAppResponse
 } from "./types.js"
 
-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 { resolveTargetDevice, listDevices } from "./resolve-device.js"
-import { startAndroidLogStream, readLogStreamLines, stopAndroidLogStream } from "./android/utils.js"
-import { startIOSLogStream, readIOSLogStreamLines, stopIOSLogStream } from "./ios/utils.js"
-import { promises as fs } from 'fs'
-import path from 'path'
-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()
-const iosInteract = new iOSInteract()
+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'
+
 
 const server = new Server(
   {
@@ -418,44 +397,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   try {
     if (name === "start_app") {
       const { platform, appId, deviceId } = args as any
-      const result = await startAppHandler({ platform, appId, deviceId })
+      const res = await (platform === 'android' ? new AndroidInteract().startApp(appId, deviceId) : new iOSInteract().startApp(appId, deviceId))
       const response: StartAppResponse = {
-        device: result.device,
-        appStarted: result.appStarted,
-        launchTimeMs: result.launchTimeMs
+        device: res.device,
+        appStarted: res.appStarted,
+        launchTimeMs: res.launchTimeMs
       }
       return wrapResponse(response)
     }
 
     if (name === "terminate_app") {
       const { platform, appId, deviceId } = args as any
-      const result = await terminateAppHandler({ platform, appId, deviceId })
-      const response: TerminateAppResponse = { device: result.device, appTerminated: result.appTerminated }
+      const res = await (platform === 'android' ? new AndroidInteract().terminateApp(appId, deviceId) : new iOSInteract().terminateApp(appId, deviceId))
+      const response: TerminateAppResponse = { device: res.device, appTerminated: res.appTerminated }
       return wrapResponse(response)
     }
 
     if (name === "restart_app") {
       const { platform, appId, deviceId } = args as any
-      const result = await restartAppHandler({ platform, appId, deviceId })
-      const response: RestartAppResponse = { device: result.device, appRestarted: result.appRestarted, launchTimeMs: result.launchTimeMs }
+      const res = await (platform === 'android' ? new AndroidInteract().restartApp(appId, deviceId) : new iOSInteract().restartApp(appId, deviceId))
+      const response: RestartAppResponse = { device: res.device, appRestarted: res.appRestarted, launchTimeMs: res.launchTimeMs }
       return wrapResponse(response)
     }
 
     if (name === "reset_app_data") {
       const { platform, appId, deviceId } = args as any
-      const result = await resetAppDataHandler({ platform, appId, deviceId })
-      const response: ResetAppDataResponse = { device: result.device, dataCleared: result.dataCleared }
+      const res = await (platform === 'android' ? new AndroidInteract().resetAppData(appId, deviceId) : new iOSInteract().resetAppData(appId, deviceId))
+      const response: ResetAppDataResponse = { device: res.device, dataCleared: res.dataCleared }
       return wrapResponse(response)
     }
 
     if (name === "install_app") {
         const { platform, appPath, deviceId } = args as any
-        const result = await installAppHandler({ platform, appPath, deviceId })
+        const res = await ToolsInteract.installAppHandler({ platform, appPath, deviceId })
         const response: InstallAppResponse = {
-          device: result.device,
-          installed: result.installed,
-          output: (result as any).output,
-          error: (result as any).error
+          device: res.device,
+          installed: res.installed,
+          output: (res as any).output,
+          error: (res as any).error
         }
         return wrapResponse(response)
       }
@@ -463,7 +442,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     if (name === "get_logs") {
       const { platform, appId, deviceId, lines } = args as any
-      const res = await getLogsHandler({ platform, appId, deviceId, lines })
+      const res = await ToolsObserve.getLogsHandler({ platform, appId, deviceId, lines })
       return {
         content: [
           { type: 'text', text: JSON.stringify({ device: res.device, result: { lines: res.logs.length, crashLines: res.crashLines.length > 0 ? res.crashLines : undefined } }, null, 2) },
@@ -474,79 +453,79 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     if (name === "list_devices") {
       const { platform, appId } = (args || {}) as any
-      const res = await listDevicesHandler({ platform, appId })
+      const res = await ToolsObserve.listDevicesHandler({ platform, appId })
       return wrapResponse(res)
     }
 
 
     if (name === "capture_screenshot") {
       const { platform, deviceId } = args as any
-      const res = await captureScreenshotHandler({ platform, deviceId })
+      const res = await ToolsObserve.captureScreenshotHandler({ platform, deviceId })
       return {
         content: [
-          { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: res.resolution } }, null, 2) },
-          { type: 'image', data: res.screenshot, mimeType: 'image/png' }
+          { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: (res as any).resolution } }, null, 2) },
+          { type: 'image', data: (res as any).screenshot, mimeType: 'image/png' }
         ]
       }
     }
 
     if (name === "get_ui_tree") {
       const { platform, deviceId } = args as any
-      const res = await getUITreeHandler({ platform, deviceId })
+      const res = await (platform === 'android' ? new AndroidObserve().getUITree(deviceId) : new iOSObserve().getUITree(deviceId))
       return wrapResponse(res)
     }
 
     if (name === "get_current_screen") {
       const { deviceId } = (args || {}) as any
-      const res = await getCurrentScreenHandler({ deviceId })
+      const res = await new AndroidObserve().getCurrentScreen(deviceId)
       return wrapResponse(res)
     }
 
     if (name === "wait_for_element") {
       const { platform, text, timeout, deviceId } = (args || {}) as any
-      const res = await waitForElementHandler({ platform, text, timeout, deviceId })
+      const res = await (platform === 'android' ? new AndroidInteract().waitForElement(text, timeout, deviceId) : new iOSInteract().waitForElement(text, timeout, deviceId))
       return wrapResponse(res)
     }
 
     if (name === "tap") {
       const { platform, x, y, deviceId } = (args || {}) as any
-      const res = await tapHandler({ platform, x, y, deviceId })
+      const res = await (platform === 'android' ? new AndroidInteract().tap(x, y, deviceId) : new iOSInteract().tap(x, y, deviceId))
       return wrapResponse(res)
     }
 
     if (name === "swipe") {
       const { x1, y1, x2, y2, duration, deviceId } = (args || {}) as any
-      const res = await swipeHandler({ x1, y1, x2, y2, duration, deviceId })
+      const res = await new AndroidInteract().swipe(x1, y1, x2, y2, duration, deviceId)
       return wrapResponse(res)
     }
 
     if (name === "type_text") {
       const { text, deviceId } = (args || {}) as any
-      const res = await typeTextHandler({ text, deviceId })
+      const res = await new AndroidInteract().typeText(text, deviceId)
       return wrapResponse(res)
     }
 
     if (name === "press_back") {
       const { deviceId } = (args || {}) as any
-      const res = await pressBackHandler({ deviceId })
+      const res = await new AndroidInteract().pressBack(deviceId)
       return wrapResponse(res)
     }
 
     if (name === 'start_log_stream') {
       const { platform, packageName, level, sessionId, deviceId } = args as any
-      const res = await startLogStreamHandler({ platform, packageName, level, sessionId, deviceId })
+      const res = await ToolsObserve.startLogStreamHandler({ platform, packageName, level, sessionId, deviceId })
       return wrapResponse(res)
     }
 
     if (name === 'read_log_stream') {
       const { platform, sessionId, limit, since } = args as any
-      const res = await readLogStreamHandler({ platform, sessionId, limit, since })
+      const res = await ToolsObserve.readLogStreamHandler({ platform, sessionId, limit, since })
       return wrapResponse(res)
     }
 
     if (name === 'stop_log_stream') {
       const { platform, sessionId } = (args || {}) as any
-      const res = await stopLogStreamHandler({ platform, sessionId })
+      const res = await ToolsObserve.stopLogStreamHandler({ platform, sessionId })
       return wrapResponse(res)
     }
   } catch (error) {

package/src/tools/interact.ts

@@ -0,0 +1,84 @@
+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 }: { platform?: 'android' | 'ios', appPath: string, deviceId?: string }) {
+    let chosenPlatform: 'android' | 'ios' | undefined = platform
+
+    try {
+      const stat = await fs.stat(appPath).catch(() => null)
+      if (stat && stat.isDirectory()) {
+        const files = (await fs.readdir(appPath).catch(() => [])) as string[]
+        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 androidInteract = new AndroidInteract()
+      const result = await androidInteract.installApp(appPath, resolved.id)
+      return result
+    } else {
+      const resolved = await resolveTargetDevice({ platform: 'ios', deviceId })
+      const iosInteract = new iOSInteract()
+      const result = await iosInteract.installApp(appPath, resolved.id)
+      return result
+    }
+  }
+
+  static async startAppHandler({ platform, appId, deviceId }: { platform: 'android' | 'ios', appId: string, deviceId?: string }) {
+    if (platform === 'android') {
+      const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
+      return await new AndroidInteract().startApp(appId, resolved.id)
+    } else {
+      const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
+      return await new iOSInteract().startApp(appId, resolved.id)
+    }
+  }
+
+  static async terminateAppHandler({ platform, appId, deviceId }: { platform: 'android' | 'ios', appId: string, deviceId?: string }) {
+    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 restartAppHandler({ platform, appId, deviceId }: { platform: 'android' | 'ios', appId: string, deviceId?: string }) {
+    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 resetAppDataHandler({ platform, appId, deviceId }: { platform: 'android' | 'ios', appId: string, deviceId?: string }) {
+    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)
+    }
+  }
+}

package/src/tools/observe.ts

@@ -0,0 +1,132 @@
+import { resolveTargetDevice, listDevices } 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 getLogsHandler({ platform, appId, deviceId, lines }: { platform: 'android' | 'ios', appId?: string, deviceId?: string, lines?: number }) {
+    if (platform === 'android') {
+      const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
+      const response = await new 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: response.device, logs, crashLines }
+    } else {
+      const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
+      const resp = await new iOSObserve().getLogs(appId, resolved.id)
+      const logs = Array.isArray(resp.logs) ? resp.logs : []
+      const crashLines = logs.filter(l => l.includes('FATAL EXCEPTION'))
+      return { device: resp.device, logs, crashLines }
+    }
+  }
+
+  static async startLogStreamHandler({ platform, packageName, level, sessionId, deviceId }: { platform?: 'android' | 'ios', packageName: string, level?: 'error' | 'warn' | 'info' | 'debug', sessionId?: string, deviceId?: string }) {
+    const effectivePlatform = platform || 'android'
+    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)
+    } 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)
+    }
+  }
+
+  static async readLogStreamHandler({ platform, sessionId, limit, since }: { platform?: 'android' | 'ios', sessionId?: string, limit?: number, since?: string }) {
+    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)
+    } else {
+      const { readIOSLogStreamLines } = await import('../ios/utils.js')
+      return await readIOSLogStreamLines(sid, limit ?? 100, since)
+    }
+  }
+
+  static async stopLogStreamHandler({ platform, sessionId }: { platform?: 'android' | 'ios', sessionId?: string }) {
+    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 }: { platform: 'android' | 'ios', deviceId?: string }) {
+    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 }: { deviceId?: string }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
+    return await new AndroidObserve().getCurrentScreen(resolved.id)
+  }
+
+  static async waitForElementHandler({ platform, text, timeout, deviceId }: { platform: 'android' | 'ios', text: string, timeout?: number, deviceId?: string }) {
+    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 }: { platform?: 'android' | 'ios', x: number, y: number, deviceId?: string }) {
+    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', deviceId })
+      return await new iOSInteract().tap(x, y, resolved.id)
+    }
+  }
+
+  static async swipeHandler({ x1, y1, x2, y2, duration, deviceId }: { x1: number, y1: number, x2: number, y2: number, duration: number, deviceId?: string }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
+    return await new AndroidInteract().swipe(x1, y1, x2, y2, duration, resolved.id)
+  }
+
+  static async typeTextHandler({ text, deviceId }: { text: string, deviceId?: string }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
+    return await new AndroidInteract().typeText(text, resolved.id)
+  }
+
+  static async pressBackHandler({ deviceId }: { deviceId?: string }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
+    return await new AndroidInteract().pressBack(resolved.id)
+  }
+
+  static async listDevicesHandler({ platform, appId }: { platform?: 'android' | 'ios', appId?: string }) {
+    const devices = await listDevices(platform as any, appId)
+    return { devices }
+  }
+
+  static async captureScreenshotHandler({ platform, deviceId }: { platform?: 'android' | 'ios', deviceId?: string }) {
+    const effectivePlatform = platform || 'android'
+    if (effectivePlatform === 'android') {
+      const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
+      return await new AndroidObserve().captureScreen(resolved.id)
+    } else {
+      const resolved = await resolveTargetDevice({ platform: 'ios', deviceId })
+      return await new iOSObserve().captureScreenshot(resolved.id)
+    }
+  }
+}
+

package/src/utils/index.ts

@@ -0,0 +1 @@
+export { detectJavaHome } from './java.js'

package/src/utils/java.ts

@@ -0,0 +1,69 @@
+import { execSync } from 'child_process'
+import { existsSync } from 'fs'
+import path from 'path'
+
+export async function detectJavaHome(): Promise<string | undefined> {
+  try {
+    // If JAVA_HOME is set, validate it's Java 17
+    if (process.env.JAVA_HOME) {
+      try {
+        const javaBin = path.join(process.env.JAVA_HOME, 'bin', 'java')
+        const v = execSync(`"${javaBin}" -version`, { stdio: ['ignore', 'pipe', 'pipe'] }).toString()
+        if (/\b17\b/.test(v) || /17\./.test(v)) return process.env.JAVA_HOME
+        console.debug('[java.detect] Existing JAVA_HOME does not appear to be Java 17, will search for JDK17')
+      } catch {
+        console.debug('[java.detect] Failed to validate existing JAVA_HOME, searching for JDK17')
+      }
+    }
+
+    // macOS explicit path
+    const explicit = '/Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home'
+    if (existsSync(explicit)) return explicit
+
+    // Android Studio JBR candidates
+    const jbrCandidates = [
+      '/Applications/Android Studio.app/Contents/jbr',
+      '/Applications/Android Studio Preview.app/Contents/jbr',
+      '/Applications/Android Studio Preview 2022.3.app/Contents/jbr',
+      '/Applications/Android Studio Preview 2023.1.app/Contents/jbr'
+    ]
+    for (const p of jbrCandidates) {
+      const javaBin = path.join(p, 'bin', 'java')
+      if (existsSync(javaBin)) {
+        try {
+          const v = execSync(`"${javaBin}" -version`, { stdio: ['ignore', 'pipe', 'pipe'] }).toString()
+          if (/\b17\b/.test(v) || /17\./.test(v)) return p
+        } catch {}
+      }
+    }
+
+    // macOS /usr/libexec/java_home
+    try {
+      const out = execSync('/usr/libexec/java_home -v 17', { stdio: ['ignore', 'pipe', 'pipe'] }).toString().trim()
+      if (out) return out
+    } catch {}
+
+    // macOS common JDK locations
+    try {
+      const homes = execSync('ls -1 /Library/Java/JavaVirtualMachines || true', { stdio: ['ignore', 'pipe', 'inherit'] }).toString().split(/\r?\n/).filter(Boolean)
+      for (const h of homes) {
+        if (h.toLowerCase().includes('17') || h.toLowerCase().includes('jdk-17')) {
+          const candidate = `/Library/Java/JavaVirtualMachines/${h}/Contents/Home`
+          return candidate
+        }
+      }
+    } catch {}
+
+    // Linux locations
+    const linuxCandidates = [
+      '/usr/lib/jvm/java-17-openjdk-amd64',
+      '/usr/lib/jvm/java-17-openjdk',
+      '/usr/lib/jvm/zulu17',
+      '/usr/lib/jvm/temurin-17-jdk'
+    ]
+    for (const p of linuxCandidates) {
+      try { if (existsSync(p)) return p } catch {}
+    }
+  } catch {}
+  return undefined
+}

package/test/integration/install.integration.ts

@@ -17,14 +17,14 @@ function isAndroidDir(p: string) {
   try {
     const listing = fs.readdirSync(p)
     return listing.includes('gradlew') || listing.some((f: string) => f.endsWith('.gradle') || f === 'app' || f === 'settings.gradle')
-  } catch (e) { return false }
+  } catch { return false }
 }
 
 function isIosDir(p: string) {
   try {
     const listing = fs.readdirSync(p)
     return listing.some((f: string) => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace'))
-  } catch (e) { return false }
+  } catch { return false }
 }
 
 let runner: string | undefined
@@ -56,7 +56,7 @@ proc.on('close', (code) => {
       console.error('Integration reported not installed:', obj)
       process.exit(4)
     }
-  } catch (e) {
+  } catch {
     console.error('Failed to parse runner output')
     console.error(stdout)
     process.exit(5)

package/test/integration/run-install-android.ts

@@ -12,7 +12,7 @@ async function main() {
   try {
     const res = await inter.installApp(appPath, deviceId)
     console.log(JSON.stringify(res, null, 2))
-  } catch (err) {
+  } catch {
     console.error('Install failed:', err instanceof Error ? err.message : String(err))
     process.exit(2)
   }

package/test/integration/run-install-ios.ts

@@ -12,7 +12,7 @@ async function main() {
   try {
     const res = await inter.installApp(appPath, deviceId || 'booted')
     console.log(JSON.stringify(res, null, 2))
-  } catch (err) {
+  } catch {
     console.error('Install failed:', err instanceof Error ? err.message : String(err))
     process.exit(2)
   }

package/test/integration/smoke-test.ts

@@ -105,7 +105,7 @@ async function main() {
 
     console.log(`\n✨ Smoke test COMPLETED SUCCESSFULLY! ✨\n`);
 
-  } catch (error) {
+  } catch {
     console.error(`\n❌ Smoke test FAILED:`, error);
     process.exit(1);
   }

package/test/integration/test-dist.ts

@@ -32,7 +32,7 @@ async function main() {
     } else {
       console.log('No screenshot returned')
     }
-  } catch (err) {
+  } catch {
     console.error('Smoke test script failed:', err)
     process.exit(1)
   }

package/test/integration/test-ui-tree.ts

@@ -67,7 +67,7 @@ async function main() {
         console.log(`- Elements with text: ${withText}`);
     }
 
-  } catch (error) {
+  } catch {
     console.error("\n❌ Test Failed:", error);
     process.exit(1);
   }

package/test/integration/wait_for_element_real.ts

@@ -72,7 +72,7 @@ async function runRealTest() {
     console.log(`Calls: ${calls} ${calls === 3 ? "PASS" : "FAIL"}`);
     console.log(`Elapsed time (should be >= 1000ms): ${elapsed3} ${elapsed3 >= 1000 ? "PASS" : "FAIL"}`);
 
-  } catch (error) {
+  } catch {
     console.error("Test failed with error:", error);
   }
 }

package/test/unit/detect-java.test.ts

@@ -0,0 +1,22 @@
+import assert from 'assert'
+import { detectJavaHome } from '../../src/utils/java.js'
+
+// These tests are lightweight smoke tests; they don't rely on actual JDK17 installs,
+// but exercise the failure modes and ensure the function returns undefined or a string.
+
+export async function run() {
+  const res = await detectJavaHome()
+  // It's acceptable for local dev env to not have JDK17; just ensure call returns (string|undefined)
+  assert.ok(typeof res === 'string' || typeof res === 'undefined')
+
+  // Basic mocking: if JAVA_HOME points to a fake path, detection should return undefined
+  const orig = process.env.JAVA_HOME
+  process.env.JAVA_HOME = '/non/existent/java/home'
+  const res2 = await detectJavaHome()
+  assert.ok(typeof res2 === 'undefined')
+  process.env.JAVA_HOME = orig
+
+  console.log('detectJavaHome tests passed')
+}
+
+run().catch((e) => { console.error(e); process.exit(1) })

package/test/unit/install.test.ts

@@ -2,7 +2,6 @@ import assert from 'assert'
 import fs from 'fs/promises'
 import os from 'os'
 import path from 'path'
-import { createRequire } from 'module'
 
 // This test mocks child_process.spawn and simulates a Gradle build producing an APK
 // and an adb install. It does not patch AndroidInteract.installApp itself so the
@@ -15,11 +14,6 @@ async function makeTempFile(ext: string) {
   return { dir, file }
 }
 
-async function makeTempDirWith(name: string) {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-test-'))
-  await fs.writeFile(path.join(dir, name), '')
-  return dir
-}
 
 export async function run() {
   // Create a fake adb executable in a temporary bin dir and prepend to PATH so