mobile-debug-mcp 0.20.1 → 0.21.1

package/dist/scripts/press_and_observe.mjs

@@ -0,0 +1,90 @@
+import { ToolsObserve } from '../observe/index.js'
+import { ToolsInteract } from '../interact/index.js'
+
+async function main() {
+  const bundle = 'com.ideamechanics.modul8'
+  const sessionId = 'press-test'
+  console.log('Starting log stream for', bundle)
+  try {
+    const start = await ToolsObserve.startLogStreamHandler({ platform: 'ios', packageName: bundle, sessionId })
+    console.log('startLogStream result:', JSON.stringify(start))
+  } catch (e) {
+    console.error('startLogStream failed:', e instanceof Error ? e.message : String(e))
+  }
+
+  // Try to find the Generate Session element
+  console.log('\nSearching for "Generate Session" UI element...')
+  let el = null
+  try {
+    const found = await ToolsInteract.findElementHandler({ query: 'Generate Session', exact: false, timeoutMs: 3000, platform: 'ios' })
+    const foundFlag = found && typeof (found).found !== 'undefined' ? found.found : false
+    console.log('findElementHandler:', foundFlag ? 'found' : 'not found')
+    if (foundFlag) {
+      el = found.element
+      console.log('Matched element:', JSON.stringify(el))
+    }
+  } catch (e) {
+    console.error('findElementHandler error:', e instanceof Error ? e.message : String(e))
+  }
+
+  // If found, tap it. Otherwise, try tapping a best-effort coordinate in center of screen
+  try {
+    if (el && el.tapCoordinates) {
+      console.log('Tapping matched element at', JSON.stringify(el.tapCoordinates))
+      await ToolsInteract.tapHandler({ platform: 'ios', x: el.tapCoordinates.x, y: el.tapCoordinates.y })
+    } else {
+      console.log('Element not found; attempting center tap as fallback')
+      // attempt a center tap (may be harmless)
+      await ToolsInteract.tapHandler({ platform: 'ios', x: 200, y: 400 })
+    }
+  } catch (e) {
+    console.error('Tap failed:', e instanceof Error ? e.message : String(e))
+  }
+
+  console.log('\nObserving until network_idle (30s timeout)')
+  // Start a parallel log monitor to print network-like lines as they appear
+  // Print all log lines originating from the app bundle for inspection
+  let seenIds = new Set()
+  let monitorActive = true
+  const monitor = (async () => {
+    while (monitorActive) {
+      try {
+        const stream = await ToolsObserve.readLogStreamHandler({ platform: 'ios', sessionId, limit: 200 })
+        const entries = (stream && Array.isArray(stream.entries)) ? stream.entries : []
+        for (const ent of entries) {
+          const id = JSON.stringify(ent).slice(0,200)
+          if (seenIds.has(id)) continue
+          seenIds.add(id)
+          const msg = ent && (ent.message || ent.msg || ent) ? (ent.message || ent.msg || ent) : ''
+          // Print only lines that reference the app bundle
+          if (String(msg).includes('Modul8') || String(msg).includes('modul8') || (ent && ent.process && String(ent.process).toLowerCase().includes('modul8'))) {
+            console.log('[APP LOG]', new Date().toISOString(), JSON.stringify({ message: msg }))
+          }
+        }
+      } catch (e) { console.error('log monitor error:', e instanceof Error ? e.message : String(e)) }
+      await new Promise(r => setTimeout(r, 300))
+    }
+  })()
+
+  let observeResult = null
+  try {
+    observeResult = await ToolsInteract.observeUntilHandler({ type: 'network_idle', timeoutMs: 30000, pollIntervalMs: 300, platform: 'ios', includeSnapshotOnFailure: true })
+    console.log('observeUntil result:')
+    console.log(JSON.stringify(observeResult, null, 2))
+  } catch (e) {
+    console.error('observeUntil failed:', e instanceof Error ? e.message : String(e))
+  }
+
+  // Stop monitor
+  monitorActive = false
+
+  console.log('\nStopping log stream (best-effort)')
+  try {
+    const stop = await ToolsObserve.stopLogStreamHandler({ platform: 'ios', sessionId })
+    console.log('stopLogStream result:', JSON.stringify(stop))
+  } catch (e) { console.error('stopLogStream failed:', e) }
+
+  process.exit(0)
+}
+
+main().catch(err => { console.error(err); process.exit(1) })

package/dist/scripts/press_and_wait_ui.mjs

@@ -0,0 +1,85 @@
+import { ToolsObserve } from '../observe/index.js'
+import { ToolsInteract } from '../interact/index.js'
+
+async function main() {
+  const bundle = 'com.ideamechanics.modul8'
+  const sessionId = 'press-ui-test'
+  console.log('Starting log stream for', bundle)
+  try {
+    const platform = process.argv.includes('--platform') ? process.argv[process.argv.indexOf('--platform')+1] : 'android'
+    const pkg = bundle
+    const sessionOpts = { platform, packageName: pkg, sessionId }
+    const start = await ToolsObserve.startLogStreamHandler(sessionOpts)
+    console.log('startLogStream result:', JSON.stringify(start))
+  } catch (e) {
+    console.error('startLogStream failed:', e instanceof Error ? e.message : String(e))
+  }
+
+  console.log('\nAttempting to find and tap Generate Session...')
+  let el = null
+  try {
+    const platform = process.argv.includes('--platform') ? process.argv[process.argv.indexOf('--platform')+1] : 'android'
+    const found = await ToolsInteract.findElementHandler({ query: 'Generate Session', exact: platform === 'android', timeoutMs: 3000, platform })
+    const foundFlag = found && typeof (found).found !== 'undefined' ? found.found : false
+    console.log('findElementHandler:', foundFlag ? 'found' : 'not found')
+    if (foundFlag) {
+      el = found.element
+      console.log('Matched element:', JSON.stringify(el))
+    }
+  } catch (e) { console.error('findElementHandler err:', e) }
+
+  try {
+    const platform = process.argv.includes('--platform') ? process.argv[process.argv.indexOf('--platform')+1] : 'android'
+    const device = process.argv.includes('--device') ? process.argv[process.argv.indexOf('--device')+1] : undefined
+
+    // Strict foreground check: ensure the package is in foreground before tapping
+    try {
+      const fg = await ToolsInteract.get_current_activity ? await ToolsInteract.get_current_activity({ platform, deviceId: device }) : null
+      console.log('Foreground activity info:', fg)
+      if (fg && fg.activity && !String(fg.activity).includes('modul8')) {
+        console.error('App is not foreground. Aborting tap.')
+        process.exit(2)
+      }
+    } catch (e) { console.warn('Foreground check failed:', e) }
+
+    if (el && el.tapCoordinates) {
+      console.log('Tapping matched element at', JSON.stringify(el.tapCoordinates))
+      await ToolsInteract.tapHandler({ platform, x: el.tapCoordinates.x, y: el.tapCoordinates.y, deviceId: device })
+    } else {
+      console.log('Element not found, tapping center fallback')
+      await ToolsInteract.tapHandler({ platform, x: 200, y: 400, deviceId: device })
+    }
+  } catch (e) { console.error('Tap failed:', e) }
+
+  console.log('\nNow waiting for "Generating session" to disappear (timeout 30s)')
+  const start = Date.now()
+  const deadline = start + (parseInt(process.argv.includes('--timeout') ? process.argv[process.argv.indexOf('--timeout')+1] : '30000'))
+  let poll = 0
+  let disappeared = false
+  const platformArg = process.argv.includes('--platform') ? process.argv[process.argv.indexOf('--platform')+1] : 'android'
+  const deviceArg = process.argv.includes('--device') ? process.argv[process.argv.indexOf('--device')+1] : undefined
+  while (Date.now() <= deadline) {
+    poll++
+    try {
+      const f = await ToolsInteract.findElementHandler({ query: 'Generating session', exact: false, timeoutMs: 1000, platform: platformArg, deviceId: deviceArg })
+      const exists = f && typeof f.found !== 'undefined' ? f.found : false
+      console.log(`poll ${poll}: generating exists=${exists}`)
+      if (!exists) { disappeared = true; break }
+    } catch (e) { console.error('findElement err:', e) }
+    await new Promise(r => setTimeout(r, 500))
+  }
+
+  const elapsed = Date.now()-start
+  console.log('Result: disappeared=', disappeared, 'polls=', poll, 'elapsedMs=', elapsed)
+
+  // Platform-specific post-conditions
+
+
+  console.log('\nFinal Result: success=', disappeared)
+
+  console.log('\nStopping log stream')
+  try { const stop = await ToolsObserve.stopLogStreamHandler({ platform: 'ios', sessionId }); console.log('stopLogStream', stop) } catch (e) { console.error('stop failed', e) }
+  process.exit(disappeared ? 0 : 2)
+}
+
+main().catch(e=>{ console.error(e); process.exit(1) })

package/dist/scripts/test_generate_and_wait.mjs

@@ -0,0 +1,123 @@
+import fs from 'fs'
+import path from 'path'
+import { ToolsObserve } from '../observe/index.js'
+import { ToolsInteract } from '../interact/index.js'
+
+const argv = process.argv.slice(2)
+const opts = { platform: 'android', deviceId: undefined, timeoutMs: 180000, stabilityMs: 1000, pollIntervalMs: 500, saveDir: '/tmp' }
+for (let i = 0; i < argv.length; i++) {
+  if (argv[i] === '--platform') opts.platform = argv[++i]
+  else if (argv[i] === '--deviceId') opts.deviceId = argv[++i]
+  else if (argv[i] === '--timeout') opts.timeoutMs = Number(argv[++i])
+  else if (argv[i] === '--stabilityMs') opts.stabilityMs = Number(argv[++i])
+  else if (argv[i] === '--poll') opts.pollIntervalMs = Number(argv[++i])
+  else if (argv[i] === '--saveDir') opts.saveDir = argv[++i]
+}
+
+const platform = opts.platform
+const deviceId = opts.deviceId
+const timeoutMs = opts.timeoutMs
+const stabilityMs = opts.stabilityMs
+const poll = opts.pollIntervalMs
+const saveDir = opts.saveDir
+
+const ts = () => Date.now()
+
+async function findAndTapGenerate() {
+  try {
+    const found = await ToolsInteract.findElementHandler({ query: 'Generate Session', exact: false, timeoutMs: 3000, platform, deviceId })
+    const foundFlag = found && typeof found.found !== 'undefined' ? found.found : false
+    console.log('find Generate Session:', foundFlag)
+    if (foundFlag) {
+      const el = found.element
+      if (el && el.tapCoordinates) {
+        console.log('Tapping at', JSON.stringify(el.tapCoordinates))
+        await ToolsInteract.tapHandler({ platform, x: el.tapCoordinates.x, y: el.tapCoordinates.y, deviceId })
+        return true
+      } else {
+        // tap center of parent bounds if available
+        if (el && el.bounds) {
+          const b = el.bounds
+          const cx = Math.floor((b.left + b.right)/2)
+          const cy = Math.floor((b.top + b.bottom)/2)
+          console.log('Tapping parent center', cx, cy)
+          await ToolsInteract.tapHandler({ platform, x: cx, y: cy, deviceId })
+          return true
+        }
+      }
+    }
+  } catch (e) { console.error('error finding/tapping generate:', e) }
+  return false
+}
+
+async function captureUITree(savePrefix) {
+  try {
+    const tree = await ToolsObserve.getUITreeHandler({ platform, deviceId })
+    const p = path.join(saveDir, `${savePrefix}_ui_${Date.now()}.json`)
+    fs.writeFileSync(p, JSON.stringify(tree, null, 2))
+    console.log('Wrote UI tree', p)
+    return tree
+  } catch (e) { console.error('failed getUITree:', e); return null }
+}
+
+async function tryCaptureScreenshot(savePrefix) {
+  try {
+    const res = await ToolsObserve.captureScreenshotHandler({ platform, deviceId })
+    // handler may return { image: 'data:image/png;base64,...' } or blocks; try to extract base64
+    let b64 = null
+    if (res && res.image && typeof res.image === 'string') b64 = res.image.replace(/^data:image\/png;base64,/, '')
+    else if (Array.isArray(res) && res.length) {
+      for (const blk of res) { if (blk && blk.mime === 'image/png' && blk.data) { b64 = blk.data; break } }
+    } else if (res && res.blocks) {
+      for (const blk of res.blocks) { if (blk && blk.mime === 'image/png' && blk.data) { b64 = blk.data; break } }
+    }
+    if (b64) {
+      const p = path.join(saveDir, `${savePrefix}_shot_${Date.now()}.png`)
+      fs.writeFileSync(p, Buffer.from(b64, 'base64'))
+      console.log('Wrote screenshot', p)
+      return p
+    }
+    console.log('No image returned from captureScreenshotHandler')
+  } catch (e) { console.error('screenshot error:', e) }
+  return null
+}
+
+async function main() {
+  console.log('Starting test: tap Generate Session and wait for Play session to appear stably')
+  const tapped = await findAndTapGenerate()
+  if (!tapped) console.log('Warning: generate tap not performed')
+
+  const start = ts()
+  const deadline = start + timeoutMs
+  let matchedAt = null
+  let pollCount = 0
+
+  while (Date.now() <= deadline) {
+    pollCount++
+    const savePrefix = `gen_wait_p${pollCount}`
+    const tree = await captureUITree(savePrefix)
+    try {
+      const f = await ToolsInteract.findElementHandler({ query: 'Play session', exact: false, timeoutMs: 500, platform, deviceId })
+      const exists = f && typeof f.found !== 'undefined' ? f.found : false
+      console.log(`poll ${pollCount}: play exists=${exists}`)
+      await tryCaptureScreenshot(savePrefix)
+      if (exists) {
+        if (matchedAt === null) matchedAt = Date.now()
+        const stable = Date.now() - matchedAt
+        if (stable >= stabilityMs) {
+          console.log('SUCCESS: Play session present and stable for', stable, 'ms after', Date.now()-start, 'ms and', pollCount, 'polls')
+          process.exit(0)
+        }
+      } else {
+        matchedAt = null
+      }
+    } catch (e) { console.error('error during poll:', e) }
+
+    await new Promise(r => setTimeout(r, poll))
+  }
+
+  console.error('FAIL: timeout waiting for Play session (polls=', pollCount, ')')
+  process.exit(2)
+}
+
+main().catch(e=>{ console.error('fatal', e); process.exit(1) })

package/dist/server.js

@@ -315,31 +315,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             }
         },
         {
-            name: "wait_for_element",
-            description: "Wait until a UI element with matching text appears on screen or timeout is reached.",
+            name: "wait_for_ui",
+            description: "Wait for a UI/log/screen/idle condition with a stability window before returning success.",
             inputSchema: {
                 type: "object",
                 properties: {
-                    platform: {
-                        type: "string",
-                        enum: ["android", "ios"],
-                        description: "Platform to check"
-                    },
-                    text: {
-                        type: "string",
-                        description: "Text content of the element to wait for"
-                    },
-                    timeout: {
-                        type: "number",
-                        description: "Max wait time in ms (default 10000)",
-                        default: 10000
-                    },
-                    deviceId: {
-                        type: "string",
-                        description: "Device Serial/UDID. Defaults to connected/booted device."
-                    }
-                },
-                required: ["platform", "text"]
+                    type: { type: "string", enum: ["ui", "log", "screen", "idle"], description: "Condition type to observe", default: "ui" },
+                    query: { type: "string", description: "Optional query string for ui/log/screen types" },
+                    timeoutMs: { type: "number", description: "Timeout in ms to wait for condition (default 30000)", default: 30000 },
+                    pollIntervalMs: { type: "number", description: "Polling interval in ms (default 300, clamped to 250-500)", default: 300 },
+                    match: { type: "string", enum: ["present", "absent"], description: "Match mode for UI checks: 'present' or 'absent' (default 'present')", default: "present" },
+                    stability_ms: { type: "number", description: "Stability window in ms that the condition must hold before returning success (default 700)", default: 700 },
+                    includeSnapshotOnFailure: { type: "boolean", description: "Whether to include a debug snapshot on timeout (default true)", default: true },
+                    platform: { type: "string", enum: ["android", "ios"], description: "Optional platform override" },
+                    deviceId: { type: "string", description: "Optional device serial/udid" }
+                }
             }
         },
         {
@@ -626,9 +616,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const res = await ToolsInteract.waitForScreenChangeHandler({ platform, previousFingerprint, timeoutMs, pollIntervalMs, deviceId });
             return wrapResponse(res);
         }
-        if (name === "wait_for_element") {
-            const { platform, text, timeout, deviceId } = (args || {});
-            const res = await ToolsInteract.waitForElementHandler({ platform, text, timeout, deviceId });
+        if (name === "wait_for_ui") {
+            const { type = 'ui', query, timeoutMs = 30000, pollIntervalMs = 300, includeSnapshotOnFailure = true, match = 'present', stability_ms = 700, observationDelayMs = 0, platform, deviceId } = (args || {});
+            const res = await ToolsInteract.waitForUIHandler({ type, query, timeoutMs, pollIntervalMs, includeSnapshotOnFailure, match, stability_ms, observationDelayMs, platform, deviceId });
             return wrapResponse(res);
         }
         if (name === "find_element") {

package/dist/system/gradle.js

@@ -19,7 +19,7 @@ function readPropertiesFile(p) {
         }
         return out;
     }
-    catch (e) {
+    catch {
         return {};
     }
 }
@@ -35,7 +35,7 @@ function javaBinExists(p) {
             return true;
         return false;
     }
-    catch (e) {
+    catch {
         return false;
     }
 }
@@ -67,7 +67,7 @@ export async function checkGradle() {
             }
         }
     }
-    catch (e) { /* ignore */ }
+    catch { }
     // 3) system gradle.properties
     const systemProps = '/etc/gradle/gradle.properties';
     filesChecked.push(systemProps);
@@ -82,7 +82,7 @@ export async function checkGradle() {
             }
         }
     }
-    catch (e) { /* ignore */ }
+    catch { }
     // 4) GRADLE_HOME fallback
     if (!gradleJavaHome && process.env.GRADLE_HOME) {
         filesChecked.push(process.env.GRADLE_HOME);

package/dist/utils/android/utils.js

@@ -82,7 +82,7 @@ export async function prepareGradle(projectPath) {
     try {
         gradleCheck = await checkGradle();
     }
-    catch (e) {
+    catch {
         gradleCheck = { gradleJavaHome: undefined, gradleValid: false, filesChecked: [], issues: [] };
     }
     const env = Object.assign({}, process.env);
@@ -127,7 +127,7 @@ export async function prepareGradle(projectPath) {
             try {
                 delete env.GRADLE_JAVA_HOME;
             }
-            catch (e) { }
+            catch { }
         }
     }
     if (platformToolsDir) {

package/dist/utils/resolve-device.js

@@ -23,6 +23,11 @@ export async function listDevices(platform, appId) {
 export async function resolveTargetDevice(opts) {
     const { platform, appId, prefer, deviceId } = opts;
     const devices = await listDevices(platform, appId);
+    // During unit tests (no adb/xcrun available), provide a lightweight mock device so
+    // the observe/interact unit tests can run without real devices.
+    if ((!devices || devices.length === 0) && (process.env.NODE_ENV === 'test' || process.env.MCP_TEST_MOCK_DEVICES === '1')) {
+        return { id: 'mock', platform: platform || 'android', osVersion: '12', model: 'Pixel', simulator: true };
+    }
     if (deviceId) {
         const found = devices.find(d => d.id === deviceId);
         if (!found)

package/docs/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
+## [0.21.1]
+- Removed wait_for_element and renamed observe_until to wait_for_ui (obsolete references removed)
+
+## [0.21.0]
+- Added `wait_for_ui` as a tool for agents to wait for things like API requests
+
 ## [0.20.1]
 - Fixes gradle home issue for android
 
@@ -21,7 +27,7 @@ All notable changes to the **Mobile Debug MCP** project will be documented in th
 
 ## [0.19.0]
 
-- Added `observe_until` interaction tool: waits for UI, log, screen fingerprint or idle conditions with configurable polling and timeout. Returns rich details on match (element info, log line, new fingerprint).
+- Added `wait_for_ui` interaction tool: waits for UI, log, screen fingerprint or idle conditions with configurable polling and timeout. Returns rich details on match (element info, log line, new fingerprint).
 
 
 ## [0.18.0]

package/docs/tools/interact.md

@@ -2,26 +2,6 @@
 
 Tools that perform UI interactions: tap, swipe, type_text, press_back, and waiting for elements.
 
-## wait_for_element
-Wait until a UI element with matching text appears on screen or timeout is reached.
-
-Input:
-
-```
-{ "platform": "android", "text": "Home", "timeout": 5000, "deviceId": "emulator-5554" }
-```
-
-Response:
-
-```
-{ "device": { "platform": "android", "id": "emulator-5554" }, "found": true, "element": { "text": "Home", "resourceId": "com.example:id/home" } }
-```
-
-Notes:
-- Polls get_ui_tree until timeout or element found. Returns an `error` field if system failures occur.
-
----
-
 ## tap / swipe / type_text / press_back
 
 Tap input example:
@@ -153,7 +133,7 @@ Notes:
 
 ---
 
-## observe_until
+## wait_for_ui
 
 Purpose:
 - Wait for a condition to occur on the device: UI element appearance, a log line, a screen fingerprint change, or an idle/stable screen state.
@@ -164,7 +144,7 @@ Supported types and behavior:
 - screen: Compares screen fingerprints (visual checks) against an initial baseline and returns when fingerprint changes. If `query` is provided it will attempt a `find_element` on the new screen to validate the expected content.
 - idle: Waits until the screen fingerprint remains stable for a short stability window (default 1000ms).
 
-Input (ToolsInteract.observeUntilHandler):
+Input (ToolsInteract.waitForUIHandler):
 ```
 { "type": "ui|log|screen|idle", "query": "optional string", "timeoutMs": 5000, "pollIntervalMs": 200, "platform": "android|ios", "deviceId": "optional device id" }
 ```
@@ -190,16 +170,16 @@ Notes & tips:
 - For UI-sensitive flows prefer type='ui' rather than relying solely on visual fingerprint changes, as some UI updates don't alter the fingerprint.
 
 Tests:
-- Unit: `test/interact/unit/observe_until.test.ts`
-- Device runner: `test/interact/device/observe_until_device.ts` (requires devices/emulators and adb/xcrun in PATH)
+- Unit: `test/interact/unit/wait_for_ui.test.ts`
+- Device runner: `test/interact/device/wait_for_ui_device.ts` (requires devices/emulators and adb/xcrun in PATH)
 
 Example:
 ```
 // Wait up to 5s for a button labeled "Generate Session" on Android
-ToolsInteract.observeUntilHandler({ type: 'ui', query: 'Generate Session', timeoutMs: 5000, platform: 'android' })
+ToolsInteract.waitForUIHandler({ type: 'ui', query: 'Generate Session', timeoutMs: 5000, platform: 'android' })
 ```
 
 Troubleshooting:
-- If observe_until(log) never matches, ensure log streaming is started for the target package and baseline logs captured correctly.
-- If observe_until(screen) times out despite visible UI change, try type='ui' to validate content-level changes.
+- If wait_for_ui(log) never matches, ensure log streaming is started for the target package and baseline logs captured correctly.
+- If wait_for_ui(screen) times out despite visible UI change, try type='ui' to validate content-level changes.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-debug-mcp",
-  "version": "0.20.1",
+  "version": "0.21.1",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "healthcheck": "tsx ./src/cli/idb/check-idb.ts",
     "install-idb": "tsx ./src/cli/idb/install-idb.ts",
     "preflight-ios": "tsx ./src/cli/ios/preflight-ios.ts",
-    "test:unit": "tsx test/unit/index.ts",
+    "test:unit": "SKIP_DEVICE_TESTS=1 tsx test/unit/index.ts",
     "test:integration": "npm run build && tsx test/device/index.ts",
     "test:device": "npm run build && tsx test/device/index.ts",
     "test": "npm run test:unit",

package/src/interact/android.ts

@@ -1,4 +1,4 @@
-import { WaitForElementResponse, TapResponse, SwipeResponse, TypeTextResponse, PressBackResponse } from "../types.js"
+import { TapResponse, SwipeResponse, TypeTextResponse, PressBackResponse } from "../types.js"
 import { execAdb, getAndroidDeviceMetadata, getDeviceInfo } from "../utils/android/utils.js"
 import { AndroidObserve } from "../observe/index.js"
 import { scrollToElementShared } from "../utils/ui/index.js"
@@ -7,37 +7,6 @@ import { scrollToElementShared } from "../utils/ui/index.js"
 export class AndroidInteract {
   private observe = new AndroidObserve();
 
-  async waitForElement(text: string, timeout: number, deviceId?: string): Promise<WaitForElementResponse> {
-    const metadata = await getAndroidDeviceMetadata("", deviceId)
-    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-    const startTime = Date.now();
-    
-    while (Date.now() - startTime < timeout) {
-      try {
-        const tree = await this.observe.getUITree(deviceId);
-        
-        if (tree.error) {
-          return { device: deviceInfo, found: false, error: tree.error };
-        }
-
-        const element = tree.elements.find(e => e.text === text);
-        if (element) {
-          return { device: deviceInfo, found: true, element };
-        }
-      } catch (e) {
-        // Ignore errors during polling and retry
-        console.error("Error polling UI tree:", e);
-      }
-      
-      const elapsed = Date.now() - startTime;
-      const remaining = timeout - elapsed;
-      if (remaining <= 0) break;
-      
-      await new Promise(resolve => setTimeout(resolve, Math.min(500, remaining)));
-    }
-    return { device: deviceInfo, found: false };
-  }
-
   async tap(x: number, y: number, deviceId?: string): Promise<TapResponse> {
     const metadata = await getAndroidDeviceMetadata("", deviceId)
     const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)