mobile-debug-mcp 0.21.5 → 0.23.0

package/test/unit/server/response_shapes.test.ts

@@ -0,0 +1,93 @@
+import assert from 'assert'
+import { handleToolCall } from '../../../src/server-core.js'
+import { ToolsManage } from '../../../src/manage/index.js'
+import { ToolsInteract } from '../../../src/interact/index.js'
+import { ToolsObserve } from '../../../src/observe/index.js'
+
+async function run() {
+  const originalInstallAppHandler = (ToolsManage as any).installAppHandler
+  const originalWaitForUIHandler = (ToolsInteract as any).waitForUIHandler
+  const originalTapElementHandler = (ToolsInteract as any).tapElementHandler
+  const originalCaptureScreenshotHandler = (ToolsObserve as any).captureScreenshotHandler
+  const originalGetUITreeHandler = (ToolsObserve as any).getUITreeHandler
+
+  try {
+    ;(ToolsManage as any).installAppHandler = async () => ({
+      device: { platform: 'android', id: 'emulator-5554', osVersion: '14', model: 'Pixel', simulator: true },
+      installed: true,
+      output: 'Success'
+    })
+
+    const installResponse = await handleToolCall('install_app', { platform: 'android', projectType: 'native', appPath: '/tmp/app.apk' })
+    assert.strictEqual((installResponse as any).content.length, 1)
+    const installPayload = JSON.parse((installResponse as any).content[0].text)
+    assert.strictEqual(installPayload.installed, true)
+    assert.strictEqual(installPayload.output, 'Success')
+    assert.strictEqual(installPayload.device.id, 'emulator-5554')
+
+    ;(ToolsInteract as any).waitForUIHandler = async () => ({
+      status: 'success',
+      matched: 1,
+      element: { text: 'Ready', bounds: [0, 0, 10, 10], index: 0, elementId: 'el_ready' },
+      metrics: { latency_ms: 12, poll_count: 1, attempts: 1 }
+    })
+
+    const waitForUIResponse = await handleToolCall('wait_for_ui', { selector: { text: 'Ready' } })
+    const waitForUIPayload = JSON.parse((waitForUIResponse as any).content[0].text)
+    assert.strictEqual(waitForUIPayload.status, 'success')
+    assert.strictEqual(waitForUIPayload.metrics.poll_count, 1)
+    assert.strictEqual(waitForUIPayload.element.text, 'Ready')
+    assert.strictEqual(waitForUIPayload.element.elementId, 'el_ready')
+
+    ;(ToolsInteract as any).tapElementHandler = async () => ({
+      success: true,
+      elementId: 'el_ready',
+      action: 'tap'
+    })
+
+    const tapElementResponse = await handleToolCall('tap_element', { elementId: 'el_ready' })
+    const tapElementPayload = JSON.parse((tapElementResponse as any).content[0].text)
+    assert.strictEqual(tapElementPayload.success, true)
+    assert.strictEqual(tapElementPayload.elementId, 'el_ready')
+    assert.strictEqual(tapElementPayload.action, 'tap')
+
+    ;(ToolsObserve as any).captureScreenshotHandler = async () => ({
+      device: { platform: 'ios', id: 'booted', osVersion: '18.0', model: 'Simulator', simulator: true },
+      screenshot: Buffer.from('png-data').toString('base64'),
+      screenshot_mime: 'image/png',
+      resolution: { width: 390, height: 844 }
+    })
+
+    const screenshotResponse = await handleToolCall('capture_screenshot', { platform: 'ios' })
+    assert.strictEqual((screenshotResponse as any).content.length, 2)
+    const screenshotMeta = JSON.parse((screenshotResponse as any).content[0].text)
+    assert.strictEqual((screenshotResponse as any).content[1].type, 'image')
+    assert.strictEqual((screenshotResponse as any).content[1].mimeType, 'image/png')
+    assert.strictEqual(screenshotMeta.result.resolution.width, 390)
+
+    ;(ToolsObserve as any).getUITreeHandler = async () => ({
+      device: { platform: 'android', id: 'mock', osVersion: '14', model: 'Pixel', simulator: true },
+      resolution: { width: 1080, height: 2400 },
+      elements: [{ text: 'Login', depth: 0, center: { x: 50, y: 20 } }]
+    })
+
+    const uiTreeResponse = await handleToolCall('get_ui_tree', { platform: 'android' })
+    const uiTreePayload = JSON.parse((uiTreeResponse as any).content[0].text)
+    assert.strictEqual(uiTreePayload.elements.length, 1)
+    assert.strictEqual(uiTreePayload.resolution.height, 2400)
+    assert.strictEqual(uiTreePayload.elements[0].text, 'Login')
+
+    console.log('server response-shape tests passed')
+  } finally {
+    ;(ToolsManage as any).installAppHandler = originalInstallAppHandler
+    ;(ToolsInteract as any).waitForUIHandler = originalWaitForUIHandler
+    ;(ToolsInteract as any).tapElementHandler = originalTapElementHandler
+    ;(ToolsObserve as any).captureScreenshotHandler = originalCaptureScreenshotHandler
+    ;(ToolsObserve as any).getUITreeHandler = originalGetUITreeHandler
+  }
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/test/unit/system/adb_version.test.ts

@@ -0,0 +1,35 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+import * as systemStatus from '../../../src/system/index.js'
+
+async function run() {
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-system-adb-'))
+  const adbPath = path.join(binDir, 'adb')
+  const originalAdbPath = process.env.ADB_PATH
+
+  try {
+    await fs.writeFile(adbPath, `#!/bin/sh
+if [ "$1" = "--version" ]; then
+  printf 'Android Debug Bridge version 1.0.41\nRevision 8f3b7\n'
+  exit 0
+fi
+if [ "$1" = "devices" ]; then
+  printf 'List of devices attached\n'
+  exit 0
+fi
+exit 0
+`, { mode: 0o755 })
+    process.env.ADB_PATH = adbPath
+    const res = await systemStatus.getSystemStatus()
+    assert.strictEqual(res.adbVersion, 'Android Debug Bridge version 1.0.41')
+    console.log('adb version parsing test passed')
+  } finally {
+    if (originalAdbPath === undefined) delete process.env.ADB_PATH
+    else process.env.ADB_PATH = originalAdbPath
+    await fs.rm(binDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+run().catch((error) => { console.error(error); process.exit(1) })

package/test/unit/system/get_system_status.test.ts

@@ -0,0 +1,20 @@
+import assert from 'assert'
+import { ensureAdbAvailable } from '../../../src/utils/android/utils.js'
+import { getXcrunCmd } from '../../../src/utils/ios/utils.js'
+import { getSystemStatus } from '../../../src/system/index.js'
+
+async function run() {
+  const payload = await getSystemStatus()
+  assert(typeof payload.success === 'boolean')
+  assert(Array.isArray(payload.issues))
+
+  const adb = ensureAdbAvailable()
+  assert(adb && typeof adb.ok === 'boolean')
+
+  const cmd = getXcrunCmd()
+  assert(typeof cmd === 'string')
+
+  console.log('get_system_status unit tests passed')
+}
+
+run().catch((error) => { console.error(error); process.exit(1) })

package/test/unit/system/system_status.test.ts

@@ -0,0 +1,141 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+
+import * as systemStatus from '../../../src/system/index.js'
+
+async function writeFakeCommands(binDir: string) {
+  const adbPath = path.join(binDir, 'adb')
+  const xcrunPath = path.join(binDir, 'xcrun')
+
+  await fs.writeFile(adbPath, `#!/bin/sh
+if [ "$1" = "--version" ]; then
+  if [ "\${ADB_VERSION_STATUS:-0}" != "0" ]; then
+    printf '%s' "\${ADB_VERSION_OUTPUT:-not found}" >&2
+    exit "\${ADB_VERSION_STATUS}"
+  fi
+  printf '%s' "\${ADB_VERSION_OUTPUT:-Android Debug Bridge version 8.1.0}"
+  exit 0
+fi
+if [ "$1" = "devices" ]; then
+  printf '%s' "\${ADB_DEVICES_OUTPUT:-List of devices attached}"
+  exit 0
+fi
+if [ "$1" = "logcat" ]; then
+  printf '%s' "\${ADB_LOGCAT_OUTPUT:-I/Tag: ok}"
+  exit 0
+fi
+if [ "$1" = "shell" ] && [ "$2" = "pm" ] && [ "$3" = "path" ]; then
+  printf '%s' "\${ADB_PM_PATH_OUTPUT:-package:/data/app/com.example/base.apk}"
+  exit 0
+fi
+printf '%s' "\${ADB_DEFAULT_OUTPUT:-OK}"
+exit 0
+`, { mode: 0o755 })
+
+  await fs.writeFile(xcrunPath, `#!/bin/sh
+if [ "$1" = "--version" ]; then
+  if [ "\${XCRUN_VERSION_STATUS:-0}" != "0" ]; then
+    printf '%s' "\${XCRUN_VERSION_OUTPUT:-not found}" >&2
+    exit "\${XCRUN_VERSION_STATUS}"
+  fi
+  printf '%s' "\${XCRUN_VERSION_OUTPUT:-xcrun version 123}"
+  exit 0
+fi
+if [ "$1" = "simctl" ] && [ "$2" = "list" ] && [ "$3" = "devices" ] && [ "$4" = "booted" ] && [ "$5" = "--json" ]; then
+  printf '%s' "\${SIMCTL_LIST_OUTPUT:-{\"devices\":{}}}"
+  exit 0
+fi
+printf '%s' "\${XCRUN_DEFAULT_OUTPUT:-ok}"
+exit 0
+`, { mode: 0o755 })
+
+  return { adbPath, xcrunPath }
+}
+
+function setScenario(env: Record<string, string | undefined>) {
+  for (const [key, value] of Object.entries(env)) {
+    if (value === undefined) delete process.env[key]
+    else process.env[key] = value
+  }
+}
+
+async function run() {
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-system-status-'))
+  const originalEnv = {
+    ADB_PATH: process.env.ADB_PATH,
+    XCRUN_PATH: process.env.XCRUN_PATH,
+    ADB_VERSION_OUTPUT: process.env.ADB_VERSION_OUTPUT,
+    ADB_VERSION_STATUS: process.env.ADB_VERSION_STATUS,
+    ADB_DEVICES_OUTPUT: process.env.ADB_DEVICES_OUTPUT,
+    ADB_LOGCAT_OUTPUT: process.env.ADB_LOGCAT_OUTPUT,
+    ADB_PM_PATH_OUTPUT: process.env.ADB_PM_PATH_OUTPUT,
+    XCRUN_VERSION_OUTPUT: process.env.XCRUN_VERSION_OUTPUT,
+    XCRUN_VERSION_STATUS: process.env.XCRUN_VERSION_STATUS,
+    SIMCTL_LIST_OUTPUT: process.env.SIMCTL_LIST_OUTPUT,
+  }
+
+  try {
+    const { adbPath, xcrunPath } = await writeFakeCommands(binDir)
+    process.env.ADB_PATH = adbPath
+    process.env.XCRUN_PATH = xcrunPath
+
+    setScenario({
+      ADB_VERSION_STATUS: '0',
+      ADB_VERSION_OUTPUT: '8.1.0\n',
+      ADB_DEVICES_OUTPUT: 'List of devices attached\nemulator-5554\tdevice product:sdk\n',
+      ADB_LOGCAT_OUTPUT: 'I/Tag: ok\n',
+      XCRUN_VERSION_STATUS: '0',
+      XCRUN_VERSION_OUTPUT: 'xcrun version 123\n',
+      SIMCTL_LIST_OUTPUT: JSON.stringify({ devices: { runtime: [{ state: 'Booted' }] } }),
+    })
+
+    const healthy = await systemStatus.getSystemStatus()
+    assert.strictEqual(healthy.success, true)
+    assert.strictEqual(healthy.adbAvailable, true)
+    assert.strictEqual(typeof healthy.adbVersion, 'string')
+
+    setScenario({
+      ADB_VERSION_STATUS: '1',
+      ADB_VERSION_OUTPUT: 'not found',
+      ADB_DEVICES_OUTPUT: 'List of devices attached\n',
+      XCRUN_VERSION_STATUS: '0',
+      XCRUN_VERSION_OUTPUT: 'xcrun version\n',
+    })
+    const missingAdb = await systemStatus.getSystemStatus()
+    assert.strictEqual(missingAdb.success, false)
+    assert(missingAdb.issues.some((issue: string) => issue.includes('ADB')))
+
+    setScenario({
+      ADB_VERSION_STATUS: '0',
+      ADB_VERSION_OUTPUT: '8.1.0\n',
+      ADB_DEVICES_OUTPUT: 'List of devices attached\nserial1\tunauthorized\nserial2\toffline\n',
+      XCRUN_VERSION_STATUS: '0',
+      XCRUN_VERSION_OUTPUT: 'xcrun version\n',
+    })
+    const unauthorized = await systemStatus.getSystemStatus()
+    assert.strictEqual(unauthorized.success, false)
+    assert(unauthorized.issues.some((issue: string) => issue.includes('unauthorized')))
+    assert(unauthorized.issues.some((issue: string) => issue.includes('offline')))
+
+    setScenario({
+      ADB_VERSION_STATUS: '0',
+      ADB_VERSION_OUTPUT: '8.1.0\n',
+      ADB_DEVICES_OUTPUT: 'List of devices attached\nemulator-5554\tdevice product:sdk\n',
+      XCRUN_VERSION_STATUS: '1',
+      XCRUN_VERSION_OUTPUT: 'not found',
+    })
+    const missingXcrun = await systemStatus.getSystemStatus()
+    assert.strictEqual(missingXcrun.iosAvailable, false)
+    assert.strictEqual(missingXcrun.adbAvailable, true)
+    assert.strictEqual(Array.isArray(missingXcrun.issues), true)
+
+    console.log('system_status checks passed')
+  } finally {
+    setScenario(originalEnv)
+    await fs.rm(binDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+run().catch((error) => { console.error(error); process.exit(1) })

package/test/{utils → unit/utils}/detect_java.test.ts

@@ -1,6 +1,6 @@
 import fs from 'fs'
 import path from 'path'
-import { detectJavaHome } from '../../src/utils/java.js'
+import { detectJavaHome } from '../../../src/utils/java.js'
 
 async function run() {
   // Create a temporary fake JDK that reports Java 17

package/test/unit/utils/exec.test.ts

@@ -0,0 +1,51 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+import { execAdbWithDiagnostics } from '../../../src/utils/diagnostics.js'
+import { execCmd } from '../../../src/utils/exec.js'
+
+async function run() {
+  const envResult = await execCmd(process.execPath, ['-e', 'console.log(process.env.MCP_EXEC_TEST); console.error("warn");'], {
+    env: { MCP_EXEC_TEST: 'hello' }
+  })
+  assert.strictEqual(envResult.exitCode, 0)
+  assert.strictEqual(envResult.stdout, 'hello')
+  assert.strictEqual(envResult.stderr, 'warn')
+
+  const timeoutResult = await execCmd(process.execPath, ['-e', 'setTimeout(() => console.log("late"), 200)'], {
+    timeout: 50
+  })
+  assert.strictEqual(timeoutResult.exitCode, null)
+  assert.strictEqual(timeoutResult.stdout, '')
+
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-exec-adb-'))
+  const adbPath = path.join(binDir, 'adb')
+  const script = `#!/bin/sh
+echo "device not found" >&2
+exit 1
+`
+  const originalAdbPath = process.env.ADB_PATH
+
+  try {
+    await fs.writeFile(adbPath, script, { mode: 0o755 })
+    process.env.ADB_PATH = adbPath
+
+    const adbResult = execAdbWithDiagnostics(['shell', 'getprop'], 'emulator-5554')
+    assert.strictEqual(adbResult.runResult.command, adbPath)
+    assert.deepStrictEqual(adbResult.runResult.args.slice(0, 2), ['-s', 'emulator-5554'])
+    assert.match(adbResult.runResult.stderr, /device not found/)
+    assert(adbResult.runResult.suggestedFixes?.some((fix) => fix.includes('adb devices')))
+
+    console.log('exec utility tests passed')
+  } finally {
+    if (typeof originalAdbPath === 'undefined') delete process.env.ADB_PATH
+    else process.env.ADB_PATH = originalAdbPath
+    await fs.rm(binDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/test/unit/utils/resolve_device.test.ts

@@ -0,0 +1,63 @@
+import assert from 'assert'
+import {
+  listDevices,
+  resolveTargetDevice,
+  _setDeviceListersForTests,
+  _resetDeviceListersForTests
+} from '../../../src/utils/resolve-device.js'
+
+async function run() {
+  try {
+    _setDeviceListersForTests({
+      listAndroidDevices: async () => ([
+        { id: 'android-1', platform: 'android', osVersion: '14', model: 'Pixel 8', simulator: true },
+        { id: 'android-2', platform: 'android', osVersion: '13', model: 'Pixel 7', simulator: false, appInstalled: true } as any
+      ]),
+      listIOSDevices: async () => ([
+        { id: 'ios-1', platform: 'ios', osVersion: '18.0', model: 'iPhone 15', simulator: true, booted: false } as any,
+        { id: 'ios-2', platform: 'ios', osVersion: '17.4', model: 'iPhone 14', simulator: true, booted: true } as any
+      ])
+    })
+
+    const combined = await listDevices()
+    assert.strictEqual(combined.length, 4)
+
+    const explicit = await resolveTargetDevice({ platform: 'android', deviceId: 'android-1' })
+    assert.strictEqual(explicit.id, 'android-1')
+
+    const preferredPhysical = await resolveTargetDevice({ platform: 'android', prefer: 'physical' })
+    assert.strictEqual(preferredPhysical.id, 'android-2')
+
+    const installedForApp = await resolveTargetDevice({ platform: 'android', appId: 'com.example.app' })
+    assert.strictEqual(installedForApp.id, 'android-2')
+
+    const bootedIOS = await resolveTargetDevice({ platform: 'ios' })
+    assert.strictEqual(bootedIOS.id, 'ios-2')
+
+    _setDeviceListersForTests({
+      listAndroidDevices: async () => ([
+        { id: 'android-a', platform: 'android', osVersion: '14.0', model: 'Pixel 8', simulator: false },
+        { id: 'android-b', platform: 'android', osVersion: '14.0', model: 'Pixel 8 Pro', simulator: false }
+      ])
+    })
+
+    await assert.rejects(
+      () => resolveTargetDevice({ platform: 'android' }),
+      (error: unknown) => {
+        assert(error instanceof Error)
+        assert.match(error.message, /Multiple matching devices found/)
+        assert.strictEqual(Array.isArray((error as any).devices), true)
+        return true
+      }
+    )
+
+    console.log('resolve-device tests passed')
+  } finally {
+    _resetDeviceListersForTests()
+  }
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/tsconfig.json

@@ -9,6 +9,6 @@
     "skipLibCheck": true,
     "esModuleInterop": true
   },
-  "exclude": ["smoke-test.ts", "test-ui-tree.ts", "test/**/*.ts"],
+  "exclude": ["test/**/*.ts"],
   "include": ["src/**/*"]
-}
+}

package/test/interact/device/run-real-test.ts

@@ -1,3 +0,0 @@
-// wait_for_element device runner removed
-console.log('wait_for_element device runner removed');
-process.exit(0);

package/test/interact/unit/wait_for_screen_change.test.ts

@@ -1,32 +0,0 @@
-import { ToolsInteract } from '../../../src/interact/index.js'
-import * as Observe from '../../../src/observe/index.js'
-
-const original = (Observe as any).ToolsObserve.getScreenFingerprintHandler
-
-async function runTests() {
-  console.log('Starting tests for wait_for_screen_change...')
-
-  // Test 1: Immediate change
-  let seq1: Array<string | null> = ['B','B']
-  ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: seq1.length ? seq1.shift() : null })
-  const start1 = Date.now()
-  const res1 = await ToolsInteract.waitForScreenChangeHandler({ platform: 'android', previousFingerprint: 'A', timeoutMs: 2000, pollIntervalMs: 50 })
-  const elapsed1 = Date.now() - start1
-  console.log('Test 1: Immediate change ->', (res1 && (res1 as any).success === true && (res1 as any).newFingerprint === 'B') ? 'PASS' : 'FAIL', 'Elapsed:', elapsed1, 'ms')
-
-  // Test 2: Transient nulls then stable change
-  let seq2: Array<string | null> = [null, null, 'B', 'B']
-  ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: seq2.length ? seq2.shift() : 'B' })
-  const res2 = await ToolsInteract.waitForScreenChangeHandler({ platform: 'android', previousFingerprint: 'A', timeoutMs: 3000, pollIntervalMs: 50 })
-  console.log('Test 2: Transient nulls ->', (res2 && (res2 as any).success === true && (res2 as any).newFingerprint === 'B') ? 'PASS' : 'FAIL')
-
-  // Test 3: Timeout
-  ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: 'A' })
-  const res3 = await ToolsInteract.waitForScreenChangeHandler({ platform: 'android', previousFingerprint: 'A', timeoutMs: 300, pollIntervalMs: 50 })
-  console.log('Test 3: Timeout ->', (res3 && (res3 as any).success === false && (res3 as any).reason === 'timeout') ? 'PASS' : 'FAIL')
-
-  // Restore original
-  ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = original
-}
-
-runTests().catch(console.error)

package/test/interact/unit/wait_for_ui.test.ts

@@ -1,76 +0,0 @@
-import { ToolsInteract } from '../../../src/interact/index.js'
-import * as Observe from '../../../src/observe/index.js'
-
-async function runTests() {
-  console.log('Starting wait_for_ui unit tests...')
-
-  const origFind = (ToolsInteract as any).findElementHandler
-  const origReadLog = (Observe as any).ToolsObserve.readLogStreamHandler
-  const origGetLogs = (Observe as any).ToolsObserve.getLogsHandler
-  const origGetFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
-  const origResolveObserve = (Observe as any).ToolsObserve.resolveObserve
-  const origGetScreenFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
-
-  try {
-    // Timeout / snapshot case: ensure snapshot captured when condition not met
-    const origCapture = (Observe as any).ToolsObserve.captureDebugSnapshotHandler
-    ;(Observe as any).ToolsObserve.captureDebugSnapshotHandler = async ({ reason }: any) => ({ reason, fingerprint: 'snap-123', ui_tree: null, logs: [] })
-    // make findElement always fail
-    (ToolsInteract as any).findElementHandler = async () => ({ found: false })
-    const resTimeout = await ToolsInteract.waitForUIHandler({ type: 'ui', query: 'WillNeverExist', timeoutMs: 500, pollIntervalMs: 100, platform: 'android' })
-    const okTimeout = resTimeout && !(resTimeout as any).success && (resTimeout as any).snapshot && (resTimeout as any).snapshot.fingerprint === 'snap-123' && (resTimeout as any).telemetry && (resTimeout as any).telemetry.pollCount > 0
-    console.log('Timeout Snapshot Test:', okTimeout ? 'PASS' : 'FAIL', JSON.stringify((resTimeout as any).telemetry || {}, null, 2))
-    ;(Observe as any).ToolsObserve.captureDebugSnapshotHandler = origCapture
-
-    // UI condition: findElement returns found on 2nd call
-    let calls = 0
-    ;(ToolsInteract as any).findElementHandler = async (args) => {
-      calls++
-      const query = (args && (args.query || args)) || ''
-      if (calls >= 2) return { found: true, element: { text: query } }
-      return { found: false }
-    }
-
-    const resUi = await ToolsInteract.waitForUIHandler({ type: 'ui', query: 'Generate Session', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
-    const okUi = resUi && (resUi as any).success && (resUi as any).telemetry && (resUi as any).telemetry.pollCount > 0 && (resUi as any).telemetry.timeToMatch >= 0
-    console.log('UI Test:', okUi ? 'PASS' : 'FAIL', JSON.stringify((resUi as any).telemetry || {}, null, 2))
-
-    // Log condition: stream empty, snapshot contains matching line
-    ;(Observe as any).ToolsObserve.readLogStreamHandler = async () => ({ entries: [ { message: 'nothing' } ] })
-    let glCalls = 0
-    ;(Observe as any).ToolsObserve.getLogsHandler = async () => {
-      glCalls++
-      if (glCalls === 1) return { device: {}, logs: ['INFO start'] }
-      return { device: {}, logs: ['INFO start', 'ERROR Exception occurred', 'Server: Boom'] }
-    }
-
-    const resLog = await ToolsInteract.waitForUIHandler({ type: 'log', query: 'Server', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
-    const okLog = resLog && (resLog as any).success && (resLog as any).telemetry && (resLog as any).telemetry.pollCount > 0 && (resLog as any).telemetry.matchSource === 'log-snapshot'
-    console.log('Log Test:', okLog ? 'PASS' : 'FAIL', JSON.stringify((resLog as any).telemetry || {}, null, 2))
-
-    // Screen condition: fingerprint changes after a few polls
-    let seq = ['A', 'A', 'B']
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: seq.length ? seq.shift() : null })
-    const resScreen = await ToolsInteract.waitForUIHandler({ type: 'screen', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
-    const okScreen = resScreen && (resScreen as any).success && (resScreen as any).telemetry && (resScreen as any).telemetry.matchSource === 'screen-fingerprint'
-    console.log('Screen Test:', okScreen ? 'PASS' : 'FAIL', JSON.stringify((resScreen as any).telemetry || {}, null, 2))
-
-    // Idle condition: stable fingerprints observed
-    let idleSeq = ['X', 'X', 'X']
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: idleSeq.length ? idleSeq.shift() : 'X' })
-    const resIdle = await ToolsInteract.waitForUIHandler({ type: 'idle', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
-    const okIdle = resIdle && (resIdle as any).success && (resIdle as any).telemetry && (resIdle as any).telemetry.matchSource === 'idle-stable'
-    console.log('Idle Test:', okIdle ? 'PASS' : 'FAIL', JSON.stringify((resIdle as any).telemetry || {}, null, 2))
-
-  } finally {
-    ;(ToolsInteract as any).findElementHandler = origFind
-    ;(Observe as any).ToolsObserve.readLogStreamHandler = origReadLog
-    ;(Observe as any).ToolsObserve.getLogsHandler = origGetLogs
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = origGetFp
-    ;(Observe as any).ToolsObserve.resolveObserve = origResolveObserve
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = origGetScreenFp
-    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = origGetScreenFp
-  }
-}
-
-runTests().catch(console.error)

package/test/interact/unit/wait_for_ui_new.test.ts

@@ -1,57 +0,0 @@
-import { ToolsInteract } from '../../../src/interact/index.js'
-import * as Observe from '../../../src/observe/index.js'
-
-async function run() {
-  console.log('Starting new wait_for_ui unit tests...')
-  const origGetUITree = (Observe as any).ToolsObserve.getUITreeHandler
-
-  try {
-    // Test 1: exact text match -> exists
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [ { text: 'Hello', resourceId: 'rid1', contentDescription: 'acc1', type: 'Button', bounds: [0,0,10,10], visible: true, clickable: false, enabled: true } ] })
-    const r1 = await ToolsInteract.waitForUIHandler({ selector: { text: 'Hello' }, condition: 'exists', timeout_ms: 1000, poll_interval_ms: 50, platform: 'android' })
-    const ok1 = r1 && r1.status === 'success' && r1.matched === 1 && r1.element && r1.element.text === 'Hello'
-    console.log('Exact match exists:', ok1 ? 'PASS' : 'FAIL', JSON.stringify(r1, null, 2))
-
-    // Test 2: contains matching
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [ { text: 'Welcome User', resourceId: 'rid2', contentDescription: 'acc2', type: 'TextView', bounds: [0,0,50,10], visible: true } ] })
-    const r2 = await ToolsInteract.waitForUIHandler({ selector: { text: 'User', contains: true }, condition: 'exists', timeout_ms: 1000, poll_interval_ms: 50, platform: 'android' })
-    const ok2 = r2 && r2.status === 'success' && r2.matched === 1 && r2.element && r2.element.text && r2.element.text.includes('Welcome')
-    console.log('Contains match:', ok2 ? 'PASS' : 'FAIL', JSON.stringify(r2, null, 2))
-
-    // Test 3: visible condition
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [ { text: 'Hidden', resourceId: 'rid3', bounds: [0,0,0,0], visible: false } ] })
-    const r3 = await ToolsInteract.waitForUIHandler({ selector: { text: 'Hidden' }, condition: 'visible', timeout_ms: 300, poll_interval_ms: 50, platform: 'android' })
-    const ok3 = r3 && r3.status === 'timeout' && r3.error && r3.error.code === 'ELEMENT_NOT_FOUND'
-    console.log('Visible negative (hidden element):', ok3 ? 'PASS' : 'FAIL', JSON.stringify(r3, null, 2))
-
-    // Test 4: clickable condition
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [ { text: 'TapMe', resourceId: 'rid4', bounds: [0,0,20,20], visible: true, clickable: true, enabled: true } ] })
-    const r4 = await ToolsInteract.waitForUIHandler({ selector: { text: 'TapMe' }, condition: 'clickable', timeout_ms: 1000, poll_interval_ms: 50, platform: 'android' })
-    const ok4 = r4 && r4.status === 'success' && r4.matched === 1 && r4.element && r4.element.index === 0
-    console.log('Clickable match:', ok4 ? 'PASS' : 'FAIL', JSON.stringify(r4, null, 2))
-
-    // Test 5: retry behavior - first attempt times out, second attempt succeeds
-    const start = Date.now()
-    let seqTree = async () => {
-      const now = Date.now()
-      // for first ~400ms return no elements, afterwards return match
-      if (now - start < 400) return { elements: [] }
-      return { elements: [ { text: 'Retried', resourceId: 'rid5', bounds: [0,0,10,10], visible: true } ] }
-    }
-    ;(Observe as any).ToolsObserve.getUITreeHandler = seqTree
-    const r5 = await ToolsInteract.waitForUIHandler({ selector: { text: 'Retried' }, condition: 'exists', timeout_ms: 200, poll_interval_ms: 50, match: undefined, retry: { max_attempts: 3, backoff_ms: 150 }, platform: 'android' })
-    const ok5 = r5 && r5.status === 'success' && r5.metrics && r5.metrics.attempts >= 2
-    console.log('Retry behavior:', ok5 ? 'PASS' : 'FAIL', JSON.stringify(r5, null, 2))
-
-    // Test 6: timeout with no selector match -> correct error code
-    (Observe as any).ToolsObserve.getUITreeHandler = async () => ({ elements: [] })
-    const r6 = await ToolsInteract.waitForUIHandler({ selector: { text: 'Nope' }, condition: 'exists', timeout_ms: 300, poll_interval_ms: 50, retry: { max_attempts: 1 }, platform: 'android' })
-    const ok6 = r6 && r6.status === 'timeout' && r6.error && r6.error.code === 'ELEMENT_NOT_FOUND'
-    console.log('Timeout no match:', ok6 ? 'PASS' : 'FAIL', JSON.stringify(r6, null, 2))
-
-  } finally {
-    (Observe as any).ToolsObserve.getUITreeHandler = origGetUITree
-  }
-}
-
-run().catch(err => { console.error('wait_for_ui_new tests failed:', err); process.exit(1) })

package/test/observe/device/wait_for_element_real.ts

@@ -1,3 +0,0 @@
-// wait_for_element device runner removed
-console.log('wait_for_element device test removed');
-process.exit(0);