mobile-debug-mcp 0.13.0 → 0.15.0

package/src/{android → utils/android}/utils.ts

@@ -1,8 +1,8 @@
 import { spawn } from 'child_process'
-import { DeviceInfo, UIElement } from "../types.js"
+import { DeviceInfo, UIElement } from "../../types.js"
 import { promises as fsPromises, existsSync } from 'fs'
 import path from 'path'
-import { detectJavaHome } from '../utils/java.js'
+import { detectJavaHome } from '../java.js'
 
 export function getAdbCmd() { return process.env.ADB_PATH || 'adb' }
 

package/src/{cli → utils/cli}/ios/run-ios-smoke.ts

@@ -1,5 +1,5 @@
-import { iOSObserve } from '../../ios/observe.js';
-import { iOSManage } from '../../ios/manage.js';
+import { iOSObserve } from '../../../observe/index.js';
+import { iOSManage } from '../../../manage/index.js';
 
 async function main() {
   const appId = process.argv[2] || 'com.apple.springboard';

package/src/{cli → utils/cli}/ios/run-ios-ui-tree-tap.ts

@@ -1,5 +1,5 @@
-import { iOSObserve } from '../../ios/observe.js';
-import { iOSInteract } from '../../ios/interact.js';
+import { iOSObserve } from '../../../observe/index.js';
+import { iOSInteract } from '../../../interact/index.js';
 
 async function main() {
   const deviceId = 'booted';
@@ -18,7 +18,7 @@ async function main() {
     process.exit(3);
   }
 
-  const clickable = tree.elements.find(e => e.clickable) || tree.elements[0];
+  const clickable = tree.elements.find((e: any) => e.clickable) || tree.elements[0];
   console.log('Using element:', clickable.text || '(no text)', 'clickable=', clickable.clickable, 'center=', clickable.center);
   const [x,y] = clickable.center || [0,0];
 

package/src/utils/diagnostics.ts

@@ -37,7 +37,7 @@ export class DiagnosticError extends Error {
 
 // Exec ADB with diagnostics — moved from src/android/diagnostics.ts
 import { spawnSync } from 'child_process'
-import { getAdbCmd } from '../android/utils.js'
+import { getAdbCmd } from './android/utils.js'
 
 export function execAdbWithDiagnostics(args: string[], deviceId?: string) {
   const adbArgs = deviceId ? ['-s', deviceId, ...args] : args

package/src/{ios → utils/ios}/utils.ts

@@ -1,8 +1,8 @@
 import { execFile, spawn, execSync, spawnSync } from "child_process"
-import { DeviceInfo } from "../types.js"
+import { DeviceInfo } from "../../types.js"
 import { promises as fsPromises } from 'fs'
 import path from 'path'
-import { makeEnvSnapshot } from '../utils/diagnostics.js'
+import { makeEnvSnapshot } from '../diagnostics.js'
 
 export function getXcrunCmd() { return process.env.XCRUN_PATH || 'xcrun' }
 

package/src/utils/resolve-device.ts

@@ -1,6 +1,6 @@
 import { DeviceInfo } from "../types.js"
-import { listAndroidDevices } from "../android/utils.js"
-import { listIOSDevices } from "../ios/utils.js"
+import { listAndroidDevices } from "./android/utils.js"
+import { listIOSDevices } from "./ios/utils.js"
 
 export interface ResolveOptions {
   platform: "android" | "ios"

package/test/{device/interact → interact/device}/smoke-test.ts

@@ -1,7 +1,6 @@
-import { AndroidObserve } from "../../src/android/observe.js";
-import { AndroidInteract } from "../../src/android/interact.js";
-import { iOSObserve } from "../../src/ios/observe.js";
-import { iOSInteract } from "../../src/ios/interact.js";
+import { AndroidObserve, iOSObserve } from "../../src/observe/index.js";
+import { AndroidInteract } from "../../src/interact/index.js";
+import { iOSInteract } from "../../src/interact/index.js";
 import fs from "fs/promises";
 
 const androidObserve = new AndroidObserve();

package/test/{device/manage → manage/device}/run-install-android.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { AndroidManage } from '../../../dist/android/manage.js'
+import { AndroidManage } from '../../../dist/utils/android/manage.js'
 
 async function main() {
   const [, , appPath, deviceId] = process.argv

package/test/{device/manage → manage/device}/run-install-ios.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { iOSManage } from '../../../dist/ios/manage.js'
+import { iOSManage } from '../../../dist/utils/ios/manage.js'
 
 async function main() {
   const [, , appPath, deviceId] = process.argv

package/test/{device/manage → manage/device}/run-install-kmp.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { ToolsManage } from '../../../dist/tools/manage.js'
+import { ToolsManage } from '../../../dist/manage/index.js'
 import path from 'path'
 
 async function main() {

package/test/{unit/manage → manage/unit}/build.test.ts

@@ -57,7 +57,7 @@ process.exit(0)
   // Prefer explicit XCODEBUILD_PATH to ensure deterministic behavior
   process.env.XCODEBUILD_PATH = xcodePath
 
-  const { ToolsManage } = await import('../../../src/tools/manage.js')
+  const { ToolsManage } = await import('../../../src/manage/index.js')
 
   try {
     const ares = await ToolsManage.buildAppHandler({ platform: 'android', projectPath: androidProject })

package/test/{unit/manage → manage/unit}/build_and_install.test.ts

@@ -93,7 +93,7 @@ process.exit(0)
   process.env.PATH = `${binDir}:${origPath}`
   process.env.XCRUN_PATH = simctlPath
 
-  const { ToolsManage } = await import('../../../src/tools/manage.js')
+  const { ToolsManage } = await import('../../../src/manage/index.js')
 
   try {
     // Android build_and_install

package/test/{unit/manage → manage/unit}/detection.test.ts

@@ -2,7 +2,7 @@ import assert from 'assert'
 import fs from 'fs/promises'
 import os from 'os'
 import path from 'path'
-import { detectProjectPlatform } from '../../../src/tools/manage.js'
+import { detectProjectPlatform } from '../../../src/manage/index.js'
 
 export async function run() {
   const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'))

package/test/{unit/manage → manage/unit}/diagnostics.test.ts

@@ -26,7 +26,7 @@ process.exit(1)
   // Prefix PATH so our fake adb is preferred but keep original PATH to allow /usr/bin/env node to work
   process.env.PATH = `${binDir}:${origPath}`
 
-  const { AndroidManage } = await import('../../../src/android/manage.js')
+  const { AndroidManage } = await import('../../../src/manage/index.js')
 
   try {
     const { dir, file: apk } = await makeTempFile('.apk')
@@ -70,7 +70,7 @@ process.exit(1)
   process.env.PATH = `${binDir2}:${origPath2}`
 
   try {
-    const { iOSManage } = await import('../../../src/ios/manage.js')
+    const { iOSManage } = await import('../../../src/manage/index.js')
     const im = new iOSManage()
     const res2 = await im.startApp('com.example.myapp')
     console.log('ios diag res', res2)

package/test/{unit/manage → manage/unit}/install.test.ts

@@ -36,7 +36,7 @@ exit 0
 
   // Import the module under test after PATH/ADB_PATH is adjusted
   console.log('DEBUG install.test ADB_PATH=', process.env.ADB_PATH, 'PATH starts with=', process.env.PATH?.split(':')[0])
-  const { AndroidManage } = await import('../../../src/android/manage.js?test=install')
+  const { AndroidManage } = await import('../../../src/manage/index.js?test=install')
 
   try {
     // Test: install with .apk file should call adb install

package/test/{unit/manage → manage/unit}/mcp_disable_autodetect.test.ts

@@ -15,7 +15,7 @@ export async function run() {
     const orig = process.env.MCP_DISABLE_AUTODETECT
     process.env.MCP_DISABLE_AUTODETECT = '1'
 
-    const { ToolsManage } = await import('../../../src/tools/manage.js')
+    const { ToolsManage } = await import('../../../src/manage/index.js')
 
     try {
       // platform and projectType are now mandatory; calling without them should return a missing-params error

package/test/{device/observe → observe/device}/logstream-real.ts

@@ -1,4 +1,4 @@
-import { AndroidObserve } from '../../src/android/observe.js'
+import { AndroidObserve } from '../../src/observe/index.js'
 
 async function sleep(ms: number) { return new Promise(r => setTimeout(r, ms)) }
 

package/test/observe/device/run-screen-fingerprint.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Device E2E: get_screen_fingerprint
+ * Usage: RUN_DEVICE_TESTS=true npx tsx run-screen-fingerprint.ts [android|ios] [deviceId]
+ */
+
+import { AndroidObserve } from '../../../src/observe/index.js'
+import { iOSObserve } from '../../../src/observe/index.js'
+
+async function main() {
+  const args = process.argv.slice(2)
+  const platform = (args[0] || 'android').toLowerCase()
+  const deviceId = args[1]
+
+  console.log(`Running screen fingerprint test for ${platform}${deviceId ? ` on ${deviceId}` : ''}`)
+
+  try {
+    const obs = platform === 'ios' ? new iOSObserve() : new AndroidObserve()
+    const id = platform === 'ios' ? (deviceId || 'booted') : deviceId
+    const res = await (obs as any).getScreenFingerprint(id)
+
+    if (res.error || !res.fingerprint) {
+      console.error('❌ Failed to compute fingerprint:', res.error)
+      process.exit(1)
+    }
+
+    console.log('Fingerprint:', res.fingerprint)
+    console.log('Activity:', res.activity || '<n/a>')
+    process.exit(0)
+  } catch (err) {
+    console.error('❌ Test failed:', err instanceof Error ? err.message : String(err))
+    process.exit(1)
+  }
+}
+
+main()

package/test/observe/device/run-scroll-test-android.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { AndroidInteract } from '../../../dist/interact/index.js'
+
+
+// Usage: tsx test/device/observe/run-scroll-test-android.ts <deviceId> <appId> <selectorText>
+const args = process.argv.slice(2)
+const DEVICE_ID = args[0] || process.env.DEVICE_ID || 'emulator-5554'
+const SELECTOR = args[2] || process.env.SELECTOR || 'Generate Session'
+
+async function main() {
+  console.log('Starting app if not running...')
+  // Best-effort tap to wake device/emulator
+  try { const tmp = new AndroidInteract(); await tmp.tap(10,10, DEVICE_ID).catch(()=>{}) } catch {}
+  await new Promise(r => setTimeout(r, 1000))
+
+  console.log('Running scroll_to_element for selector:', SELECTOR)
+  // Use ToolsInteract from dist to call the handler
+  const ToolsInteract = (await import('../../../dist/interact/index.js')).ToolsInteract
+
+  const res = await (ToolsInteract as any).scrollToElementHandler({ platform: 'android', selector: { text: SELECTOR }, direction: 'down', maxScrolls: 10, scrollAmount: 0.7, deviceId: DEVICE_ID })
+  console.log('Result:', JSON.stringify(res, null, 2))
+}
+
+main().catch(console.error)

package/test/{device/observe → observe/device}/test-ui-tree.ts

@@ -9,8 +9,8 @@
  *   npx tsx test-ui-tree.ts ios booted
  */
 
-import { AndroidObserve } from '../../src/android/observe.js';
-import { iOSObserve } from '../../src/ios/observe.js';
+import { AndroidObserve } from '../../src/observe/index.js';
+import { iOSObserve } from '../../src/observe/index.js';
 
 async function main() {
   const args = process.argv.slice(2);

package/test/{device/observe → observe/device}/wait_for_element_real.ts

@@ -1,5 +1,5 @@
-import { AndroidInteract } from "../../src/android/interact.js";
-import { AndroidObserve } from "../../src/android/observe.js";
+import { AndroidInteract } from "../../src/interact/index.js";
+import { AndroidObserve } from "../../src/observe/index.js";
 
 // Usage: npx tsx test/wait_for_element_real.ts <deviceId> <appId>
 const args = process.argv.slice(2);

package/test/observe/unit/get_screen_fingerprint.test.ts

@@ -0,0 +1,69 @@
+import { AndroidObserve } from '../../../src/observe/index.js'
+
+async function run() {
+  console.log('Starting get_screen_fingerprint unit tests...')
+
+  const origGet = (AndroidObserve as any).prototype.getUITree
+  const origCurrent = (AndroidObserve as any).prototype.getCurrentScreen
+
+  // Test 1: stable identical screens produce same fingerprint
+  ;(AndroidObserve as any).prototype.getUITree = async function() {
+    return {
+      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+      screen: '',
+      resolution: { width: 1080, height: 1920 },
+      elements: [
+        { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0,0,1080,100], resourceId: 'id/title' },
+        { text: 'Sign in', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0,200,200,260], resourceId: 'id/signin' }
+      ]
+    }
+  }
+
+  ;(AndroidObserve as any).prototype.getCurrentScreen = async function() {
+    return { device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true }, package: 'com.example', activity: 'com.example.MainActivity', shortActivity: 'MainActivity' }
+  }
+
+  const ai = new AndroidObserve()
+  const a = await ai.getScreenFingerprint('mock')
+  const b = await ai.getScreenFingerprint('mock')
+  console.log('Test 1:', a.fingerprint === b.fingerprint ? 'PASS' : 'FAIL')
+
+  // Test 2: change in UI text changes fingerprint
+  ;(AndroidObserve as any).prototype.getUITree = async function() {
+    return {
+      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+      screen: '',
+      resolution: { width: 1080, height: 1920 },
+      elements: [
+        { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0,0,1080,100], resourceId: 'id/title' },
+        { text: 'Profile', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0,200,200,260], resourceId: 'id/signin' }
+      ]
+    }
+  }
+
+  const c = await ai.getScreenFingerprint('mock')
+  console.log('Test 2:', a.fingerprint !== c.fingerprint ? 'PASS' : 'FAIL')
+
+  // Test 3: dynamic text ignored (timestamp) should not change fingerprint
+  ;(AndroidObserve as any).prototype.getUITree = async function() {
+    return {
+      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+      screen: '',
+      resolution: { width: 1080, height: 1920 },
+      elements: [
+        { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0,0,1080,100], resourceId: 'id/title' },
+        { text: 'Sign in', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0,200,200,260], resourceId: 'id/signin' },
+        { text: '12:34', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [900,10,1080,40], resourceId: null }
+      ]
+    }
+  }
+
+  const d = await ai.getScreenFingerprint('mock')
+  console.log('Test 3:', a.fingerprint === d.fingerprint ? 'PASS' : 'FAIL')
+
+  // Restore
+  ;(AndroidObserve as any).prototype.getUITree = origGet
+  ;(AndroidObserve as any).prototype.getCurrentScreen = origCurrent
+}
+
+run().catch(console.error)

package/test/{unit/observe → observe/unit}/logparse.test.ts

@@ -1,4 +1,4 @@
-import { parseLogLine } from '../../../src/android/utils.js'
+import { parseLogLine } from '../../../src/utils/android/utils.js'
 
 function assert(cond: boolean, msg?: string) { if (!cond) throw new Error(msg || 'Assertion failed') }
 

package/test/{unit/observe → observe/unit}/logstream.test.ts

@@ -1,7 +1,7 @@
 import { promises as fs } from 'fs'
 import os from 'os'
 import path from 'path'
-import { AndroidObserve } from '../../../src/android/observe.js'
+import { AndroidObserve } from '../../../src/observe/index.js'
 
 async function run() {
   const tmp = os.tmpdir()

package/test/observe/unit/scroll_to_element.test.ts

@@ -0,0 +1,129 @@
+import { ToolsInteract } from '../../../src/interact/index.js'
+import { ToolsObserve } from '../../../src/observe/index.js'
+
+const origGet = (ToolsObserve as any).getUITreeHandler
+const origSwipe = (ToolsInteract as any).swipeHandler
+
+async function runTests() {
+  // Use a stable logger to avoid test harness replacing console.log between calls
+  console.log = (...args: any[]) => { try { process.stdout.write(args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n') } catch {} }
+  console.log('Starting tests for scroll_to_element...')
+
+  // Test 1: Element found immediately
+  console.log('\nTest 1: Element found immediately')
+  (ToolsObserve as any).getUITreeHandler = async () => ({
+    device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+    screen: '',
+    resolution: { width: 1080, height: 1920 },
+    elements: [{
+      text: 'Target',
+      type: 'Button',
+      contentDescription: null,
+      clickable: true,
+      enabled: true,
+      visible: true,
+      bounds: [0, 0, 100, 100],
+      resourceId: null
+    }]
+  })
+
+  const res1 = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: 'Target' }, direction: 'down', maxScrolls: 5, scrollAmount: 0.7 })
+  console.log('Result:', res1.success === true ? 'PASS' : 'FAIL')
+  console.log('scrollsPerformed:', (res1 as any).scrollsPerformed)
+
+  // Test 2: Element found after scrolling
+  console.log('\nTest 2: Element found after scrolling')
+  let calls = 0
+  (ToolsObserve as any).getUITreeHandler = async () => {
+    calls++
+    if (calls < 3) {
+      return {
+        device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+        screen: '',
+        resolution: { width: 1080, height: 1920 },
+        elements: []
+      }
+    }
+    return {
+      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+      screen: '',
+      resolution: { width: 1080, height: 1920 },
+      elements: [{
+        text: 'Target',
+        type: 'Button',
+        contentDescription: null,
+        clickable: true,
+        enabled: true,
+        visible: true,
+        bounds: [0, 0, 100, 100],
+        resourceId: null
+      }]
+    }
+  }
+
+  // Stub swipe so it doesn't try to call adb/idb
+  (ToolsInteract as any).swipeHandler = async () => ({ success: true })
+
+  const res2 = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: 'Target' }, direction: 'down', maxScrolls: 5, scrollAmount: 0.7 })
+  console.log('Result:', res2.success === true ? 'PASS' : 'FAIL')
+  console.log('calls:', calls, calls >= 3 ? 'PASS' : 'FAIL')
+
+  // Test 3: UI unchanged stops early
+  console.log('\nTest 3: UI unchanged stops early')
+  (ToolsObserve as any).getUITreeHandler = async () => ({
+    device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+    screen: '',
+    resolution: { width: 1080, height: 1920 },
+    elements: []
+  })
+
+  (ToolsInteract as any).swipeHandler = async () => ({ success: true })
+
+  const res3 = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: 'Missing' }, direction: 'down', maxScrolls: 5, scrollAmount: 0.7 })
+  console.log('Result:', res3.success === false && (res3 as any).attempts === 1 ? 'PASS' : 'FAIL')
+  console.log('Reason:', (res3 as any).reason || JSON.stringify(res3))
+
+  // Test 4: Offscreen element scrolls into view
+  console.log('\nTest 4: Offscreen element scrolls into view')
+  const ai = new (await import('../../../src/interact/index.js')).AndroidInteract()
+  const origObserveGet = ai['observe'].getUITree
+  const origAiSwipe = ai.swipe
+  let swiped = false
+  let swipeCalled = 0
+  ;(ai['observe'] as any).getUITree = async () => {
+    if (!swiped) {
+      return {
+        device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+        screen: '',
+        resolution: { width: 1080, height: 1920 },
+        elements: [ { text: null, type: 'android.view.View', resourceId: null, contentDescription: null, bounds: [0,0,1080,200], visible: true } ]
+      }
+    }
+    return {
+      device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+      screen: '',
+      resolution: { width: 1080, height: 1920 },
+      elements: [{ text: 'OffscreenTarget', type: 'android.widget.Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [100,400,300,460], resourceId: null }]
+    }
+  }
+  ;(ai as any).swipe = async () => { swipeCalled++; swiped = true; return { success: true } }
+
+  const r4 = await ai.scrollToElement({ text: 'OffscreenTarget' }, 'down', 3, 0.7, 'mock')
+  const ok4 = r4 && (r4 as any).success === true && (r4 as any).scrollsPerformed === 1 && swipeCalled === 1
+  console.log('Result:', ok4 ? 'PASS' : 'FAIL')
+  console.log('  success:', (r4 as any).success, 'scrollsPerformed:', (r4 as any).scrollsPerformed, 'swipeCalled:', swipeCalled)
+
+  ;(ai['observe'] as any).getUITree = origObserveGet
+  ;(ai as any).swipe = origAiSwipe
+
+  // Restore
+  (ToolsObserve as any).getUITreeHandler = origGet
+  ;(ToolsInteract as any).swipeHandler = origSwipe
+}
+
+// Ensure console.log is a function (some test runners replace it)
+if (typeof console.log !== 'function') {
+  console.log = (...args: any[]) => { try { process.stdout.write(args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n') } catch { /* swallow */ } }
+}
+
+runTests().catch(console.error)

package/test/{unit/observe → observe/unit}/wait_for_element_mock.ts

@@ -1,5 +1,5 @@
-import { AndroidInteract } from '../../../src/android/interact.js';
-import { AndroidObserve } from '../../../src/android/observe.js';
+import { AndroidInteract } from '../../../src/interact/index.js';
+import { AndroidObserve } from '../../../src/observe/index.js';
 
 const originalGetUITree = (AndroidObserve as any).prototype.getUITree;
 
@@ -95,7 +95,7 @@ async function runTests() {
   const elapsed4 = Date.now() - start4;
   console.log("Result:", result4.found === false && result4.error === "ADB Connection Failed" ? "PASS" : "FAIL");
   console.log("Error Message:", result4.error);
-  console.log("Elapsed time (should be < 500ms):", elapsed4, elapsed4 < 500 ? "PASS" : "FAIL");
+  console.log("Elapsed time (should be < 1000ms):", elapsed4, elapsed4 < 1000 ? "PASS" : "FAIL");
 
   // Restore
   (AndroidObserve as any).prototype.getUITree = originalGetUITree;

package/test/unit/index.ts

@@ -1,13 +1,14 @@
-// Aggregator entrypoint for unit tests
-import './utils/detect-java.test.ts'
-import './observe/logparse.test.ts'
-import './observe/logstream.test.ts'
-import './observe/wait_for_element_mock.ts'
-import './manage/install.test.ts'
-import './manage/build.test.ts'
-import './manage/build_and_install.test.ts'
-import './manage/diagnostics.test.ts'
-import './manage/detection.test.ts'
-import './manage/mcp_disable_autodetect.test.ts'
+// Aggregator entrypoint for unit tests (updated to new test layout)
+import '../observe/unit/logparse.test.ts'
+import '../observe/unit/logstream.test.ts'
+import '../observe/unit/wait_for_element_mock.ts'
+import '../observe/unit/get_screen_fingerprint.test.ts'
+
+import '../manage/unit/install.test.ts'
+import '../manage/unit/build.test.ts'
+import '../manage/unit/build_and_install.test.ts'
+import '../manage/unit/diagnostics.test.ts'
+import '../manage/unit/detection.test.ts'
+import '../manage/unit/mcp_disable_autodetect.test.ts'
 
 console.log('Unit tests loaded.')

package/src/tools/interact.ts

@@ -1,45 +0,0 @@
-import { resolveTargetDevice } from '../utils/resolve-device.js'
-import { AndroidInteract } from '../android/interact.js'
-import { iOSInteract } from '../ios/interact.js'
-
-export class ToolsInteract {
-
-  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)
-  }
-
-}
-