mobile-debug-mcp 0.10.0 → 0.12.0

package/src/server.ts

@@ -14,12 +14,11 @@ import {
   InstallAppResponse
 } from "./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(
@@ -146,6 +145,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["appPath"]
       }
     },
+    {
+      name: "build_app",
+      description: "Build a project for Android or iOS and return the built artifact path. Does not install.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          platform: { type: "string", enum: ["android", "ios"], description: "Optional. If omitted the server will attempt to detect platform from projectPath files." },
+          projectPath: { type: "string", description: "Path to project directory (contains gradlew or xcodeproj/xcworkspace)" },
+          variant: { type: "string", description: "Optional build variant (e.g., Debug/Release)" }
+        },
+        required: ["projectPath"]
+      }
+    },
     {
       name: "get_logs",
       description: "Get recent logs from Android or iOS simulator. Returns device metadata and the log output.",
@@ -397,7 +409,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   try {
     if (name === "start_app") {
       const { platform, appId, deviceId } = args as any
-      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: StartAppResponse = {
         device: res.device,
         appStarted: res.appStarted,
@@ -408,28 +420,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     if (name === "terminate_app") {
       const { platform, appId, deviceId } = args as any
-      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: TerminateAppResponse = { device: res.device, appTerminated: res.appTerminated }
       return wrapResponse(response)
     }
 
     if (name === "restart_app") {
       const { platform, appId, deviceId } = args as any
-      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: 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 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: ResetAppDataResponse = { device: res.device, dataCleared: res.dataCleared }
       return wrapResponse(response)
     }
 
     if (name === "install_app") {
         const { platform, appPath, deviceId } = args as any
-        const res = await ToolsInteract.installAppHandler({ platform, appPath, deviceId })
+        const res = await ToolsManage.installAppHandler({ platform, appPath, deviceId })
         const response: InstallAppResponse = {
           device: res.device,
           installed: res.installed,
@@ -439,6 +451,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return wrapResponse(response)
       }
 
+      if (name === "build_app") {
+        const { platform, projectPath, variant } = args as any
+        const res = await ToolsManage.buildAppHandler({ platform, projectPath, variant })
+        return wrapResponse(res)
+      }
+
+      if (name === 'build_and_install') {
+        const { platform, projectPath, deviceId, timeout } = args as any
+        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 as any
@@ -453,7 +483,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     if (name === "list_devices") {
       const { platform, appId } = (args || {}) as any
-      const res = await ToolsObserve.listDevicesHandler({ platform, appId })
+      const res = await ToolsManage.listDevicesHandler({ platform, appId })
       return wrapResponse(res)
     }
 
@@ -471,43 +501,43 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     if (name === "get_ui_tree") {
       const { platform, deviceId } = args as any
-      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 || {}) as any
-      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 || {}) as any
-      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 || {}) as any
-      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 || {}) as any
-      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 || {}) as any
-      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 || {}) as any
-      const res = await new AndroidInteract().pressBack(deviceId)
+      const res = await ToolsInteract.pressBackHandler({ deviceId })
       return wrapResponse(res)
     }
 

package/src/tools/interact.ts

@@ -1,84 +1,45 @@
-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') {
+  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 })
-      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 }: { 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)
+  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', 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 }: { 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 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 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 typeTextHandler({ text, deviceId }: { text: string, deviceId?: string }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
+    return await new AndroidInteract().typeText(text, 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)
-    }
+  static async pressBackHandler({ deviceId }: { deviceId?: string }) {
+    const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
+    return await new AndroidInteract().pressBack(resolved.id)
   }
+
 }
+

package/src/tools/manage.ts

@@ -0,0 +1,171 @@
+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'
+import type { InstallAppResponse, StartAppResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse } from '../types.js'
+
+export class ToolsManage {
+  static async buildAppHandler({ platform, projectPath, variant }: { platform?: 'android' | 'ios', projectPath: string, variant?: string }) {
+    // delegate to platform-specific build implementations
+    const chosen = platform || 'android'
+    if (chosen === 'android') {
+      const android = new AndroidManage()
+      const artifact = await (android as any).build(projectPath, variant)
+      return artifact
+    } else {
+      const ios = new iOSManage()
+      const artifact = await (ios as any).build(projectPath, variant)
+      return artifact
+    }
+  }
+
+  static async installAppHandler({ platform, appPath, deviceId }: { platform?: 'android' | 'ios', appPath: string, deviceId?: string }): Promise<InstallAppResponse> {
+    let chosenPlatform: 'android' | 'ios' | undefined = 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(() => [])) 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 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 }: { platform: 'android' | 'ios', appId: string, deviceId?: string }): Promise<StartAppResponse> {
+    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 }: { platform: 'android' | 'ios', appId: string, deviceId?: string }): Promise<TerminateAppResponse> {
+    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 }: { platform: 'android' | 'ios', appId: string, deviceId?: string }): Promise<RestartAppResponse> {
+    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 }: { platform: 'android' | 'ios', appId: string, deviceId?: string }): Promise<ResetAppDataResponse> {
+    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 }: { platform?: 'android' | 'ios', projectPath: string, deviceId?: string, timeout?: number }) {
+    const events: string[] = []
+    const pushEvent = (obj: any) => 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(() => [])) as string[]
+          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: any
+    try {
+      buildRes = await ToolsManage.buildAppHandler({ platform: chosenPlatform as any, projectPath })
+      if (buildRes && (buildRes as any).error) {
+        pushEvent({ type: 'build', status: 'failed', error: (buildRes as any).error })
+        return { ndjson: events.join('\n') + '\n', result: { success: false, error: (buildRes as any).error } }
+      }
+      pushEvent({ type: 'build', status: 'finished', artifactPath: (buildRes as any).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 as any).artifactPath || projectPath
+    pushEvent({ type: 'install', status: 'started', artifactPath: artifact, deviceId })
+    let installRes: any
+    try {
+      installRes = await ToolsManage.installAppHandler({ platform: chosenPlatform as any, 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 }: { platform?: 'android' | 'ios', appId?: string }) {
+    const devices = await listDevices(platform as any, appId)
+    return { devices }
+  }
+}

package/src/tools/observe.ts

@@ -1,10 +1,23 @@
-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 }: { 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 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 })
@@ -26,14 +39,12 @@ 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)
     }
   }
 
@@ -41,11 +52,9 @@ export class ToolsObserve {
     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)
     }
   }
 
@@ -53,71 +62,12 @@ export class ToolsObserve {
     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)
+      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 }: { 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') {

package/src/types.ts

@@ -10,22 +10,30 @@ export interface StartAppResponse {
   device: DeviceInfo;
   appStarted: boolean;
   launchTimeMs: number;
+  error?: string;
+  diagnostics?: any;
 }
 
 export interface TerminateAppResponse {
   device: DeviceInfo;
   appTerminated: boolean;
+  error?: string;
+  diagnostics?: any;
 }
 
 export interface RestartAppResponse {
   device: DeviceInfo;
   appRestarted: boolean;
   launchTimeMs: number;
+  error?: string;
+  diagnostics?: any;
 }
 
 export interface ResetAppDataResponse {
   device: DeviceInfo;
   dataCleared: boolean;
+  error?: string;
+  diagnostics?: any;
 }
 
 export interface GetLogsResponse {
@@ -133,4 +141,5 @@ export interface InstallAppResponse {
   installed: boolean;
   output?: string;
   error?: string;
+  diagnostics?: any;
 }

package/src/utils/diagnostics.ts

@@ -0,0 +1,36 @@
+export type RunResult = {
+  exitCode: number | null
+  stdout: string
+  stderr: string
+  envSnapshot: Record<string,string | undefined>
+  command: string
+  args: string[]
+  suggestedFixes?: string[]
+}
+
+export function makeEnvSnapshot(keys: string[]) {
+  const snap: Record<string,string|undefined> = {}
+  for (const k of keys) snap[k] = process.env[k]
+  return snap
+}
+
+export function wrapExecResult(command: string, args: string[], res: { status: number | null, stdout?: string | Buffer, stderr?: string | Buffer }) : RunResult {
+  return {
+    exitCode: res.status,
+    stdout: res.stdout ? (typeof res.stdout === 'string' ? res.stdout : res.stdout.toString()) : '',
+    stderr: res.stderr ? (typeof res.stderr === 'string' ? res.stderr : res.stderr.toString()) : '',
+    envSnapshot: makeEnvSnapshot(['PATH','IDB_PATH','JAVA_HOME','HOME']),
+    command,
+    args,
+    suggestedFixes: []
+  }
+}
+
+export class DiagnosticError extends Error {
+  runResult: RunResult
+  constructor(message: string, runResult: RunResult) {
+    super(message)
+    this.name = 'DiagnosticError'
+    this.runResult = runResult
+  }
+}