mobile-debug-mcp 0.9.0 → 0.11.0

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/build.test.ts

@@ -0,0 +1,84 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+
+// Test build_app handler by creating fake gradlew and xcodebuild behaviours
+
+async function makeTempProject(platform: 'android' | 'ios') {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), `mcp-build-${platform}-`))
+  if (platform === 'android') {
+    const gradlew = path.join(dir, 'gradlew')
+    const script = `#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+const apk = path.join(process.cwd(),'app','build','outputs','apk','debug','app-debug.apk')
+fs.mkdirSync(path.dirname(apk), { recursive: true })
+fs.writeFileSync(apk, 'fake-apk')
+console.log('BUILD SUCCESS')
+process.exit(0)
+`
+    await fs.writeFile(gradlew, script, { mode: 0o755 })
+  } else {
+    // create minimal Xcode workspace structure
+    const ws = path.join(dir, 'Example.xcworkspace')
+    await fs.writeFile(ws, '')
+    const script = `#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+const app = path.join(process.cwd(),'Build','Products','Debug-iphonesimulator','Example.app')
+fs.mkdirSync(app, { recursive: true })
+fs.writeFileSync(path.join(app,'Info.plist'), '<plist/>')
+console.log('BUILD SUCCESS')
+process.exit(0)
+`
+    const xbuild = path.join(dir, 'xcodebuild')
+    await fs.writeFile(xbuild, script, { mode: 0o755 })
+  }
+  return dir
+}
+
+export async function run() {
+  const androidProject = await makeTempProject('android')
+  const iosProject = await makeTempProject('ios')
+
+  // Create a fake xcodebuild in PATH for the iOS build step
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-xcode-bin-'))
+  const xcodeScript = `#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+// emulate xcodebuild by creating an Example.app inside Build/Products/Debug-iphonesimulator
+const app = path.join(process.cwd(),'Build','Products','Debug-iphonesimulator','Example.app')
+fs.mkdirSync(app, { recursive: true })
+fs.writeFileSync(path.join(app,'Info.plist'), '<plist/>')
+console.log('xcodebuild simulated')
+process.exit(0)
+`
+  const xcodePath = path.join(binDir, 'xcodebuild')
+  await fs.writeFile(xcodePath, xcodeScript, { mode: 0o755 })
+
+  const origPath = process.env.PATH || ''
+  process.env.PATH = `${binDir}:${origPath}`
+
+  const { ToolsManage } = await import('../../src/tools/manage.js')
+
+  try {
+    const ares = await ToolsManage.buildAppHandler({ platform: 'android', projectPath: androidProject })
+    console.log('android build', ares)
+    assert.ok((ares as any).artifactPath && (ares as any).artifactPath.endsWith('.apk'))
+
+    const ires = await ToolsManage.buildAppHandler({ platform: 'ios', projectPath: iosProject })
+    console.log('ios build', ires)
+    assert.ok((ires as any).artifactPath && (ires as any).artifactPath.endsWith('.app'))
+
+    console.log('build tests passed')
+  } finally {
+    // cleanup
+    await fs.rm(androidProject, { recursive: true, force: true }).catch(() => {})
+    await fs.rm(iosProject, { recursive: true, force: true }).catch(() => {})
+    await fs.rm(binDir, { recursive: true, force: true }).catch(() => {})
+    process.env.PATH = origPath
+  }
+}
+
+run().catch(e => { console.error(e); process.exit(1) })

package/test/unit/build_and_install.test.ts

@@ -0,0 +1,132 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+
+async function makeAndroidProject() {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-build-ai-android-'))
+  const gradlew = path.join(dir, 'gradlew')
+  const script = `#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+const apk = path.join(process.cwd(),'app','build','outputs','apk','debug','app-debug.apk')
+fs.mkdirSync(path.dirname(apk), { recursive: true })
+fs.writeFileSync(apk, 'fake-apk')
+console.log('BUILD SUCCESS')
+process.exit(0)
+`
+  await fs.writeFile(gradlew, script, { mode: 0o755 })
+  return dir
+}
+
+async function makeIOSProject() {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-build-ai-ios-'))
+  const ws = path.join(dir, 'Example.xcworkspace')
+  await fs.writeFile(ws, '')
+  return dir
+}
+
+export async function run() {
+  const androidProject = await makeAndroidProject()
+  const iosProject = await makeIOSProject()
+
+  // Create fake bin dir with adb and simctl
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-bin-'))
+  const adbPath = path.join(binDir, 'adb')
+  const adbScript = `#!/usr/bin/env node
+const args = process.argv.slice(2)
+if (args.includes('devices')) {
+  console.log('List of devices attached')
+  console.log('emulator-5554\tdevice product:sdk_gphone64_arm64')
+  process.exit(0)
+}
+if (args.includes('install')) {
+  console.log('Performing Streamed Install')
+  console.log('Success')
+  process.exit(0)
+}
+if (args.includes('shell')) {
+  const idx = args.indexOf('shell')
+  const shellArgs = args.slice(idx+1)
+  if (shellArgs[0] === 'getprop') {
+    console.log('')
+    process.exit(0)
+  }
+  console.log('Success')
+  process.exit(0)
+}
+console.log('OK')
+process.exit(0)
+`
+  await fs.writeFile(adbPath, adbScript, { mode: 0o755 })
+
+  const simctlPath = path.join(binDir, 'simctl')
+  const simctlScript = `#!/usr/bin/env node
+const args = process.argv.slice(2)
+if (args.includes('install')) {
+  console.log('simctl install simulated')
+  process.exit(0)
+}
+// Respond to 'list devices --json'
+if (args.includes('list') && args.includes('devices') && args.includes('--json')) {
+  const out = { devices: { 'com.apple.CoreSimulator.SimRuntime.iOS-17-0': [ { udid: 'booted', name: 'iPhone 14', state: 'Booted' } ] } }
+  console.log(JSON.stringify(out))
+  process.exit(0)
+}
+console.log('simctl ok')
+process.exit(0)
+`
+  await fs.writeFile(simctlPath, simctlScript, { mode: 0o755 })
+
+  // fake xcodebuild for iOS build step
+  const xcodeScript = `#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+const app = path.join(process.cwd(),'Build','Products','Debug-iphonesimulator','Example.app')
+fs.mkdirSync(app, { recursive: true })
+fs.writeFileSync(path.join(app,'Info.plist'), '<plist/>')
+console.log('xcodebuild simulated')
+process.exit(0)
+`
+  const xcodePath = path.join(binDir, 'xcodebuild')
+  await fs.writeFile(xcodePath, xcodeScript, { mode: 0o755 })
+
+  const origPath = process.env.PATH || ''
+  const origXcrun = process.env.XCRUN_PATH
+  process.env.PATH = `${binDir}:${origPath}`
+  process.env.XCRUN_PATH = simctlPath
+
+  const { ToolsManage } = await import('../../src/tools/manage.js')
+
+  try {
+    // Android build_and_install
+    const ares = await ToolsManage.buildAndInstallHandler({ platform: 'android', projectPath: androidProject, deviceId: 'emulator-5554' })
+    console.log('android ndjson:\n', ares.ndjson)
+    console.log('android result:', ares.result)
+    assert.ok(ares.result.success === true, 'android build_and_install should succeed')
+    assert.ok(ares.result.artifactPath && ares.result.artifactPath.endsWith('.apk'))
+    assert.ok(ares.ndjson.includes('"type":"build"'))
+    assert.ok(ares.ndjson.includes('"type":"install"'))
+
+    // iOS build_and_install
+    const ires = await ToolsManage.buildAndInstallHandler({ platform: 'ios', projectPath: iosProject, deviceId: 'booted' })
+    console.log('ios ndjson:\n', ires.ndjson)
+    console.log('ios result:', ires.result)
+    assert.ok(ires.result.success === true, 'ios build_and_install should succeed')
+    assert.ok(ires.result.artifactPath && ires.result.artifactPath.endsWith('.app'))
+    assert.ok(ires.ndjson.includes('"type":"build"'))
+    assert.ok(ires.ndjson.includes('"type":"install"'))
+
+    console.log('build_and_install tests passed')
+  } finally {
+    process.env.PATH = origPath
+    if (origXcrun === undefined) delete process.env.XCRUN_PATH
+    else process.env.XCRUN_PATH = origXcrun
+    await fs.rm(androidProject, { recursive: true, force: true }).catch(() => {})
+    await fs.rm(iosProject, { recursive: true, force: true }).catch(() => {})
+    await fs.rm(binDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+
+run().catch(e => { console.error(e); process.exit(1) })

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
@@ -37,12 +31,12 @@ process.exit(0)
   process.env.PATH = `${binDir}:${origPath}`
 
   // Import the module under test after PATH is adjusted
-  const { AndroidInteract } = await import('../../src/android/interact.js')
+  const { AndroidManage } = await import('../../src/android/manage.js')
 
   try {
     // Test: install with .apk file should call adb install
     const { dir: d1, file: apk } = await makeTempFile('.apk')
-    const ai = new AndroidInteract()
+    const ai = new AndroidManage()
     const res1 = await ai.installApp(apk)
     console.log('res1', res1)
     assert.ok(res1.installed === true, 'APK install should succeed')

package/test/unit/logstream.test.ts

@@ -1,11 +1,12 @@
 import { promises as fs } from 'fs'
 import os from 'os'
 import path from 'path'
-import { readLogStreamLines, _setActiveLogStream, _clearActiveLogStream } from '../../src/android/utils.js'
+import { AndroidObserve } from '../../src/android/observe.js'
 
 async function run() {
   const tmp = os.tmpdir()
-  const file = path.join(tmp, `test-mobile-debug-log-${Date.now()}.ndjson`)
+  const sessionId = 'unit-test-logstream'
+  const file = path.join(tmp, `mobile-debug-log-${sessionId}.ndjson`)
 
   // Prepare NDJSON with one crash entry and one info entry
   const crashEntry = { timestamp: '2026-03-13T14:00:00.000Z', level: 'E', tag: 'AndroidRuntime', message: 'FATAL EXCEPTION: main\njava.lang.NullPointerException' }
@@ -13,12 +14,11 @@ async function run() {
 
   await fs.writeFile(file, JSON.stringify(crashEntry) + '\n' + JSON.stringify(infoEntry) + '\n')
 
-  const sessionId = 'unit-test-logstream'
-  _setActiveLogStream(sessionId, file)
 
   try {
-    // Read all
-    const { entries, crash_summary } = await readLogStreamLines(sessionId, 10)
+    // Read all via AndroidObserve (falls back to session NDJSON file)
+    const obs = new AndroidObserve()
+    const { entries, crash_summary } = await obs.readLogStream(sessionId, 10)
     if (!Array.isArray(entries) || entries.length !== 2) throw new Error('Expected 2 entries')
     if (!crash_summary || crash_summary.crash_detected !== true) throw new Error('Expected crash_detected true')
     if (!crash_summary.exception || !/NullPointerException/.test(crash_summary.exception)) throw new Error('Expected NullPointerException detected')
@@ -27,18 +27,17 @@ async function run() {
 
     // Test since filter (after first entry)
     const since = new Date('2026-03-13T14:00:30.000Z').toISOString()
-    const r2 = await readLogStreamLines(sessionId, 10, since)
+    const r2 = await obs.readLogStream(sessionId, 10, since)
     if (r2.entries.length !== 1) throw new Error('Expected 1 entry after since filter')
     console.log('Test 2 PASS: since filter')
 
     // Test limit
-    const r3 = await readLogStreamLines(sessionId, 1)
+    const r3 = await obs.readLogStream(sessionId, 1)
     if (r3.entries.length !== 1) throw new Error('Expected 1 entry with limit=1')
     console.log('Test 3 PASS: limit works')
 
     console.log('ALL logstream tests passed')
   } finally {
-    _clearActiveLogStream(sessionId)
     await fs.unlink(file).catch(()=>{})
   }
 }

package/src/tools/app.ts

@@ -1,46 +0,0 @@
-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 startAppHandler({ platform, appId, deviceId }: { platform: 'android' | 'ios', appId: string, deviceId?: string }) {
-  if (platform === 'android') {
-    const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-    return await androidInteract.startApp(appId, resolved.id)
-  } else {
-    const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-    return await iosInteract.startApp(appId, resolved.id)
-  }
-}
-
-export async function terminateAppHandler({ platform, appId, deviceId }: { platform: 'android' | 'ios', appId: string, deviceId?: string }) {
-  if (platform === 'android') {
-    const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-    return await androidInteract.terminateApp(appId, resolved.id)
-  } else {
-    const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-    return await iosInteract.terminateApp(appId, resolved.id)
-  }
-}
-
-export async function restartAppHandler({ platform, appId, deviceId }: { platform: 'android' | 'ios', appId: string, deviceId?: string }) {
-  if (platform === 'android') {
-    const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-    return await androidInteract.restartApp(appId, resolved.id)
-  } else {
-    const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-    return await iosInteract.restartApp(appId, resolved.id)
-  }
-}
-
-export async function resetAppDataHandler({ platform, appId, deviceId }: { platform: 'android' | 'ios', appId: string, deviceId?: string }) {
-  if (platform === 'android') {
-    const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-    return await androidInteract.resetAppData(appId, resolved.id)
-  } else {
-    const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-    return await iosInteract.resetAppData(appId, resolved.id)
-  }
-}

package/src/tools/devices.ts

@@ -1,6 +0,0 @@
-import { listDevices } from '../resolve-device.js'
-
-export async function listDevicesHandler({ platform, appId }: { platform?: 'android' | 'ios', appId?: string }) {
-  const devices = await listDevices(platform as any, appId)
-  return { devices }
-}

package/src/tools/install.ts

@@ -1,43 +0,0 @@
-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 }: { 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 (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/src/tools/logs.ts

@@ -1,62 +0,0 @@
-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 }: { platform: 'android' | 'ios', appId?: string, deviceId?: string, lines?: number }) {
-  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 }: { 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 })
-    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 }: { platform?: 'android' | 'ios', sessionId?: string, limit?: number, since?: string }) {
-  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 }: { platform?: 'android' | 'ios', sessionId?: string }) {
-  const effectivePlatform = platform || 'android'
-  const sid = sessionId || 'default'
-  if (effectivePlatform === 'android') {
-    return await stopAndroidLogStream(sid)
-  } else {
-    return await stopIOSLogStream(sid)
-  }
-}

package/src/tools/screenshot.ts

@@ -1,18 +0,0 @@
-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 }: { platform: 'android' | 'ios', deviceId?: string }) {
-  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/src/tools/ui.ts

@@ -1,62 +0,0 @@
-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 }: { platform: 'android' | 'ios', deviceId?: string }) {
-  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 }: { deviceId?: string }) {
-  const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-  return await androidObserve.getCurrentScreen(resolved.id)
-}
-
-export async function 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 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 }: { 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 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 }: { x1: number, y1: number, x2: number, y2: number, duration: number, deviceId?: string }) {
-  const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-  return await androidInteract.swipe(x1, y1, x2, y2, duration, resolved.id)
-}
-
-export async function typeTextHandler({ text, deviceId }: { text: string, deviceId?: string }) {
-  const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-  return await androidInteract.typeText(text, resolved.id)
-}
-
-export async function pressBackHandler({ deviceId }: { deviceId?: string }) {
-  const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-  return await androidInteract.pressBack(resolved.id)
-}