mobile-debug-mcp 0.8.0 → 0.10.0

package/src/ios/utils.ts

@@ -125,7 +125,7 @@ export async function getIOSDeviceMetadata(deviceId: string = "booted"): Promise
           }
         }
         resolve(fallback)
-      } catch (error) {
+      } catch {
         resolve(fallback)
       }
     })
@@ -169,7 +169,7 @@ export async function listIOSDevices(appId?: string): Promise<DeviceInfo[]> {
         }
 
         Promise.all(checks).then(() => resolve(out)).catch(() => resolve(out))
-      } catch (e) {
+      } catch {
         resolve([])
       }
     })
@@ -192,14 +192,14 @@ export function _clearIOSActiveLogStream(sessionId: string) {
   iosActiveLogStreams.delete(sessionId)
 }
 
-export async function startIOSLogStream(bundleId: string, level: 'error' | 'warn' | 'info' | 'debug' = 'error', deviceId: string = 'booted', sessionId: string = 'default') : Promise<{ success: boolean; stream_started?: boolean; error?: string }> {
+export async function startIOSLogStream(bundleId: string, deviceId: string = 'booted', sessionId: string = 'default') : Promise<{ success: boolean; stream_started?: boolean; error?: string }> {
   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) {}
+      try { iosActiveLogStreams.get(sessionId)!.proc.kill() } catch {}
       iosActiveLogStreams.delete(sessionId)
     }
 
@@ -231,14 +231,14 @@ export async function startIOSLogStream(bundleId: string, level: 'error' | 'warn
       }
     })
 
-    proc.on('close', (code) => {
+    proc.on('close', () => {
       stream.end()
       iosActiveLogStreams.delete(sessionId)
     })
 
     iosActiveLogStreams.set(sessionId, { proc, file })
     return { success: true, stream_started: true }
-  } catch (err) {
+  } catch {
     return { success: false, error: 'log_stream_start_failed' }
   }
 }
@@ -246,7 +246,7 @@ export async function startIOSLogStream(bundleId: string, level: 'error' | 'warn
 export async function stopIOSLogStream(sessionId: string = 'default'): Promise<{ success: boolean }> {
   const entry = iosActiveLogStreams.get(sessionId)
   if (!entry) return { success: true }
-  try { entry.proc.kill() } catch (e) {}
+  try { entry.proc.kill() } catch {}
   iosActiveLogStreams.delete(sessionId)
   return { success: true }
 }
@@ -284,7 +284,7 @@ export async function readIOSLogStreamLines(sessionId: string = 'default', 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) {
+  } catch {
     return { entries: [], crash_summary: { crash_detected: false } }
   }
 }

package/src/server.ts

@@ -8,32 +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 { 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 androidObserve = new AndroidObserve()
-const androidInteract = new AndroidInteract()
-const iosObserve = new iOSObserve()
-const iosInteract = new iOSInteract()
 
 const server = new Server(
   {
@@ -148,15 +135,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: "install_app",
-      description: "Install an app on Android (apk) or iOS simulator/device (ipa/.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"] },
-          appPath: { type: "string", description: "Path to APK (Android) or .app/.ipa (iOS) on the host machine" },
+          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: ["platform", "appPath"]
+        required: ["appPath"]
       }
     },
     {
@@ -409,444 +396,137 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
   try {
     if (name === "start_app") {
-      const { platform, appId, deviceId } = args as {
-        platform: "android" | "ios"
-        appId: string
-        deviceId?: string
-      }
-
-      let appStarted: boolean
-      let launchTimeMs: number
-      let deviceInfo: DeviceInfo
-
-      if (platform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-        const result = await androidInteract.startApp(appId, resolved.id)
-        appStarted = result.appStarted
-        launchTimeMs = result.launchTimeMs
-        deviceInfo = result.device
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-        const result = await iosInteract.startApp(appId, resolved.id)
-        appStarted = result.appStarted
-        launchTimeMs = result.launchTimeMs
-        deviceInfo = result.device
-      }
-
+      const { platform, appId, deviceId } = args as any
+      const res = await (platform === 'android' ? new AndroidInteract().startApp(appId, deviceId) : new iOSInteract().startApp(appId, deviceId))
       const response: StartAppResponse = {
-        device: deviceInfo,
-        appStarted,
-        launchTimeMs
+        device: res.device,
+        appStarted: res.appStarted,
+        launchTimeMs: res.launchTimeMs
       }
-
       return wrapResponse(response)
     }
 
     if (name === "terminate_app") {
-      const { platform, appId, deviceId } = args as {
-        platform: "android" | "ios"
-        appId: string
-        deviceId?: string
-      }
-
-      let appTerminated: boolean
-      let deviceInfo: DeviceInfo
-
-      if (platform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-        const result = await androidInteract.terminateApp(appId, resolved.id)
-        appTerminated = result.appTerminated
-        deviceInfo = result.device
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-        const result = await iosInteract.terminateApp(appId, resolved.id)
-        appTerminated = result.appTerminated
-        deviceInfo = result.device
-      }
-
-      const response: TerminateAppResponse = {
-        device: deviceInfo,
-        appTerminated
-      }
-
+      const { platform, appId, deviceId } = args as any
+      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 {
-        platform: "android" | "ios"
-        appId: string
-        deviceId?: string
-      }
-
-      let appRestarted: boolean
-      let launchTimeMs: number
-      let deviceInfo: DeviceInfo
-
-      if (platform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-        const result = await androidInteract.restartApp(appId, resolved.id)
-        appRestarted = result.appRestarted
-        launchTimeMs = result.launchTimeMs
-        deviceInfo = result.device
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-        const result = await iosInteract.restartApp(appId, resolved.id)
-        appRestarted = result.appRestarted
-        launchTimeMs = result.launchTimeMs
-        deviceInfo = result.device
-      }
-
-      const response: RestartAppResponse = {
-        device: deviceInfo,
-        appRestarted,
-        launchTimeMs
-      }
-
+      const { platform, appId, deviceId } = args as any
+      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 {
-        platform: "android" | "ios"
-        appId: string
-        deviceId?: string
-      }
-
-      let dataCleared: boolean
-      let deviceInfo: DeviceInfo
-
-      if (platform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-        const result = await androidInteract.resetAppData(appId, resolved.id)
-        dataCleared = result.dataCleared
-        deviceInfo = result.device
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-        const result = await iosInteract.resetAppData(appId, resolved.id)
-        dataCleared = result.dataCleared
-        deviceInfo = result.device
-      }
-
-      const response: ResetAppDataResponse = {
-        device: deviceInfo,
-        dataCleared
-      }
-
+      const { platform, appId, deviceId } = args as any
+      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 {
-        platform: "android" | "ios"
-        appPath: string
-        deviceId?: string
-      }
-
-      let installed: boolean
-      let output: string | undefined
-      let deviceInfo: DeviceInfo
-      let errorMsg: string | undefined
-
-      if (platform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-        const result = await androidInteract.installApp(appPath, resolved.id)
-        installed = result.installed
-        output = (result as any).output
-        deviceInfo = result.device
-        errorMsg = (result as any).error
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId })
-        const result = await iosInteract.installApp(appPath, resolved.id)
-        installed = result.installed
-        output = (result as any).output
-        deviceInfo = result.device
-        errorMsg = (result as any).error
-      }
-
-      const response: InstallAppResponse = {
-        device: deviceInfo,
-        installed,
-        output,
-        error: errorMsg
+        const { platform, appPath, deviceId } = args as any
+        const res = await ToolsInteract.installAppHandler({ platform, appPath, deviceId })
+        const response: InstallAppResponse = {
+          device: res.device,
+          installed: res.installed,
+          output: (res as any).output,
+          error: (res as any).error
+        }
+        return wrapResponse(response)
       }
 
-      return wrapResponse(response)
-    }
 
     if (name === "get_logs") {
-      const { platform, appId, deviceId, lines } = args as {
-        platform: "android" | "ios"
-        appId?: string
-        deviceId?: string
-        lines?: number
-      }
-
-      let logs: string[]
-      let deviceInfo: DeviceInfo
-
-      if (platform === "android") {
-        // Resolve an explicit target device when multiple are attached
-        const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-        deviceInfo = resolved
-        const response = await androidObserve.getLogs(appId, lines ?? 200, resolved.id)
-        logs = Array.isArray(response.logs) ? response.logs : []
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-        deviceInfo = resolved
-        const response = await iosObserve.getLogs(appId, resolved.id)
-        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 { platform, appId, deviceId, lines } = args as any
+      const res = await ToolsObserve.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 || {}) as { platform?: "android" | "ios"; appId?: string }
-      const devices = await listDevices(platform, appId)
-      return wrapResponse({ devices })
+      const { platform, appId } = (args || {}) as any
+      const res = await ToolsObserve.listDevicesHandler({ platform, appId })
+      return wrapResponse(res)
     }
 
 
     if (name === "capture_screenshot") {
-      const { platform, deviceId } = args as { platform: "android" | "ios"; deviceId?: string }
-
-      let screenshot: string
-      let resolution: { width: number; height: number }
-      let deviceInfo: DeviceInfo
-
-      if (platform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-        deviceInfo = resolved
-        const result = await androidObserve.captureScreen(resolved.id)
-        screenshot = result.screenshot
-        resolution = result.resolution
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId })
-        deviceInfo = resolved
-        const result = await iosObserve.captureScreenshot(resolved.id)
-        screenshot = result.screenshot
-        resolution = result.resolution
-      }
-
+      const { platform, deviceId } = args as any
+      const res = await ToolsObserve.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 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 { platform: "android" | "ios", deviceId?: string }
-      
-      let result: GetUITreeResponse
-      if (platform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-        result = await androidObserve.getUITree(resolved.id)
-      } else if (platform === "ios") {
-        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId })
-        result = await iosObserve.getUITree(resolved.id)
-      } else {
-        throw new Error(`Platform ${platform} not supported for get_ui_tree`)
-      }
-
-      return wrapResponse(result)
+      const { platform, deviceId } = args as any
+      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 { deviceId?: string }
-      const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-      const result = await androidObserve.getCurrentScreen(resolved.id)
-      return wrapResponse(result)
+      const { deviceId } = (args || {}) as any
+      const res = await new AndroidObserve().getCurrentScreen(deviceId)
+      return wrapResponse(res)
     }
 
     if (name === "wait_for_element") {
-      const { platform, text, timeout, deviceId } = (args || {}) as {
-        platform: "android" | "ios"
-        text: string
-        timeout?: number
-        deviceId?: string
-      }
-      
-      const effectiveTimeout = timeout ?? 10000;
-      
-      let result: WaitForElementResponse;
-      if (platform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-        result = await androidInteract.waitForElement(text, effectiveTimeout, resolved.id)
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId })
-        result = await iosInteract.waitForElement(text, effectiveTimeout, resolved.id)
-      }
-      return wrapResponse(result)
+      const { platform, text, timeout, deviceId } = (args || {}) as any
+      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 {
-        platform?: "android" | "ios"
-        x: number
-        y: number
-        deviceId?: string
-      }
-
-      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: TapResponse;
-      if (effectivePlatform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-        result = await androidInteract.tap(x, y, resolved.id)
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', deviceId })
-        result = await iosInteract.tap(x, y, resolved.id)
-      }
-      return wrapResponse(result)
+      const { platform, x, y, deviceId } = (args || {}) as any
+      const res = await (platform === 'android' ? new AndroidInteract().tap(x, y, deviceId) : new iOSInteract().tap(x, y, deviceId))
+      return wrapResponse(res)
     }
 
     if (name === "swipe") {
-      const { platform, x1, y1, x2, y2, duration, deviceId } = (args || {}) as {
-        platform?: "android"
-        x1: number
-        y1: number
-        x2: number
-        y2: number
-        duration: number
-        deviceId?: string
-      }
-
-      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: SwipeResponse;
-      if (effectivePlatform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-        result = await androidInteract.swipe(x1, y1, x2, y2, duration, resolved.id)
-      } else {
-        throw new Error(`Platform ${effectivePlatform} not supported for swipe`)
-      }
-      return wrapResponse(result)
+      const { x1, y1, x2, y2, duration, deviceId } = (args || {}) as any
+      const res = await new AndroidInteract().swipe(x1, y1, x2, y2, duration, deviceId)
+      return wrapResponse(res)
     }
 
     if (name === "type_text") {
-      const { platform, text, deviceId } = (args || {}) as {
-        platform?: "android"
-        text: string
-        deviceId?: string
-      }
-
-      const effectivePlatform = platform || "android";
-      
-      if (typeof text !== 'string') {
-        throw new Error("text is required and must be a string");
-      }
-
-      let result: TypeTextResponse;
-      if (effectivePlatform === "android") {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-        result = await androidInteract.typeText(text, resolved.id)
-      } else {
-        throw new Error(`Platform ${effectivePlatform} not supported for type_text`)
-      }
-      return wrapResponse(result)
+      const { text, deviceId } = (args || {}) as any
+      const res = await new AndroidInteract().typeText(text, deviceId)
+      return wrapResponse(res)
     }
 
     if (name === "press_back") {
-      const { platform, deviceId } = (args || {}) as {
-        platform?: "android"
-        deviceId?: string
-      }
-      
-      const effectivePlatform = platform || "android";
-      
-      if (effectivePlatform !== "android") {
-        throw new Error(`Platform ${effectivePlatform} not supported for press_back`)
-      }
-
-      const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-      const result = await androidInteract.pressBack(resolved.id)
-      return wrapResponse(result)
+      const { deviceId } = (args || {}) as any
+      const res = await new AndroidInteract().pressBack(deviceId)
+      return wrapResponse(res)
     }
 
     if (name === 'start_log_stream') {
-      const { platform, packageName, level, sessionId: argSession, deviceId } = args as { platform?: 'android' | 'ios'; packageName: string; level?: 'error' | 'warn' | 'info' | 'debug'; sessionId?: string; deviceId?: string }
-      const sessionId = argSession || 'default'
-      const effectivePlatform = platform || 'android'
-      if (effectivePlatform === 'android') {
-        const resolved = await resolveTargetDevice({ platform: 'android', appId: packageName, deviceId })
-        const res = await startAndroidLogStream(packageName, level || 'error', resolved.id, sessionId)
-        return wrapResponse(res)
-      } else {
-        const resolved = await resolveTargetDevice({ platform: 'ios', appId: packageName, deviceId })
-        const res = await startIOSLogStream(packageName, level || 'error', resolved.id, sessionId)
-        return wrapResponse(res)
-      }
+      const { platform, packageName, level, sessionId, deviceId } = args as any
+      const res = await ToolsObserve.startLogStreamHandler({ platform, packageName, level, sessionId, deviceId })
+      return wrapResponse(res)
     }
 
     if (name === 'read_log_stream') {
-      const { platform, sessionId: argSession, limit, since } = (args || {}) as { platform?: 'android' | 'ios'; sessionId?: string, limit?: number, since?: string }
-      const sid = argSession || 'default'
-      const effectivePlatform = platform || 'android'
-      if (effectivePlatform === 'android') {
-        const { entries, crash_summary } = await readLogStreamLines(sid, limit ?? 100, since)
-        return wrapResponse({ entries, crash_summary })
-      } else {
-        const { entries, crash_summary } = await readIOSLogStreamLines(sid, limit ?? 100, since)
-        return wrapResponse({ entries, crash_summary })
-      }
+      const { platform, sessionId, limit, since } = args as any
+      const res = await ToolsObserve.readLogStreamHandler({ platform, sessionId, limit, since })
+      return wrapResponse(res)
     }
 
     if (name === 'stop_log_stream') {
-      const { platform, sessionId: argSession } = (args || {}) as { platform?: 'android' | 'ios'; sessionId?: string }
-      const sid = argSession || 'default'
-      const effectivePlatform = platform || 'android'
-      if (effectivePlatform === 'android') {
-        const res = await stopAndroidLogStream(sid)
-        return wrapResponse(res)
-      } else {
-        const res = await stopIOSLogStream(sid)
-        return wrapResponse(res)
-      }
+      const { platform, sessionId } = (args || {}) as any
+      const res = await ToolsObserve.stopLogStreamHandler({ platform, sessionId })
+      return wrapResponse(res)
     }
   } catch (error) {
     return {