mobile-debug-mcp 0.14.0 → 0.16.0

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/{device/observe → observe/device}/run-scroll-test-android.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { AndroidInteract } from '../../../dist/android/interact.js'
+import { AndroidInteract } from '../../../dist/interact/index.js'
 
 
 // Usage: tsx test/device/observe/run-scroll-test-android.ts <deviceId> <appId> <selectorText>
@@ -15,7 +15,7 @@ async function main() {
 
   console.log('Running scroll_to_element for selector:', SELECTOR)
   // Use ToolsInteract from dist to call the handler
-  const ToolsInteract = (await import('../../../dist/tools/interact.js')).ToolsInteract
+  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))

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/{unit/observe → observe/unit}/scroll_to_element.test.ts

@@ -1,5 +1,5 @@
-import { ToolsInteract } from '../../../src/tools/interact.js'
-import { ToolsObserve } from '../../../src/tools/observe.js'
+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
@@ -85,7 +85,7 @@ async function runTests() {
 
   // Test 4: Offscreen element scrolls into view
   console.log('\nTest 4: Offscreen element scrolls into view')
-  const ai = new (await import('../../../src/android/interact.js')).AndroidInteract()
+  const ai = new (await import('../../../src/interact/index.js')).AndroidInteract()
   const origObserveGet = ai['observe'].getUITree
   const origAiSwipe = ai.swipe
   let swiped = false

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;
 

package/test/unit/index.ts

@@ -1,13 +1,15 @@
-// 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'
+import '../interact/unit/wait_for_screen_change.test.ts'
 
 console.log('Unit tests loaded.')

package/src/tools/observe.ts

@@ -1,82 +0,0 @@
-import { resolveTargetDevice } from '../utils/resolve-device.js'
-import { AndroidObserve } from '../android/observe.js'
-import { iOSObserve } from '../ios/observe.js'
-
-export class ToolsObserve {
-  static async getUITreeHandler({ platform, deviceId }: { platform: 'android' | 'ios', deviceId?: string }) {
-    if (platform === 'android') {
-      const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-      return await new AndroidObserve().getUITree(resolved.id)
-    } else {
-      const resolved = await resolveTargetDevice({ platform: 'ios', deviceId })
-      return await new iOSObserve().getUITree(resolved.id)
-    }
-  }
-
-  static async getCurrentScreenHandler({ deviceId }: { deviceId?: string }) {
-    const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-    return await new AndroidObserve().getCurrentScreen(resolved.id)
-  }
-
-  static async getLogsHandler({ platform, appId, deviceId, lines }: { platform: 'android' | 'ios', appId?: string, deviceId?: string, lines?: number }) {
-    if (platform === 'android') {
-      const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId })
-      const response = await new 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: response.device, logs, crashLines }
-    } else {
-      const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId })
-      const resp = await new iOSObserve().getLogs(appId, resolved.id)
-      const logs = Array.isArray(resp.logs) ? resp.logs : []
-      const crashLines = logs.filter(l => l.includes('FATAL EXCEPTION'))
-      return { device: resp.device, logs, crashLines }
-    }
-  }
-
-  static async 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 })
-      // Delegate to AndroidObserve's log stream methods
-      return await new AndroidObserve().startLogStream(packageName, level || 'error', resolved.id, sid)
-    } else {
-      const resolved = await resolveTargetDevice({ platform: 'ios', appId: packageName, deviceId })
-      // Delegate to iOSObserve for starting log streams
-      return await new iOSObserve().startLogStream(packageName, resolved.id, sid)
-    }
-  }
-
-  static async 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 new AndroidObserve().readLogStream(sid, limit ?? 100, since)
-    } else {
-      return await new iOSObserve().readLogStream(sid, limit ?? 100, since)
-    }
-  }
-
-  static async stopLogStreamHandler({ platform, sessionId }: { platform?: 'android' | 'ios', sessionId?: string }) {
-    const effectivePlatform = platform || 'android'
-    const sid = sessionId || 'default'
-    if (effectivePlatform === 'android') {
-      return await new AndroidObserve().stopLogStream(sid)
-    } else {
-      return await new iOSObserve().stopLogStream(sid)
-    }
-  }
-
-  static async captureScreenshotHandler({ platform, deviceId }: { platform?: 'android' | 'ios', deviceId?: string }) {
-    const effectivePlatform = platform || 'android'
-    if (effectivePlatform === 'android') {
-      const resolved = await resolveTargetDevice({ platform: 'android', deviceId })
-      return await new AndroidObserve().captureScreen(resolved.id)
-    } else {
-      const resolved = await resolveTargetDevice({ platform: 'ios', deviceId })
-      return await new iOSObserve().captureScreenshot(resolved.id)
-    }
-  }
-}
-

package/test/device/README.md

@@ -1,49 +0,0 @@
-Device-dependent integration tests
-
-Overview
-
-This folder contains integration tests that require a simulator or a real device (Android/iOS). These tests exercise real device flows (install, start, UI-tree, logs, interaction) and are intentionally gated from the default CI to avoid failures on runners without devices.
-
-Prerequisites
-
-- Build the project: npm run build
-- Android: adb available (set ADB_PATH if custom) and a connected device or emulator
-- iOS: idb (fb-idb) and idb_companion installed and available. Prefer setting MCP_IDB_PATH or IDB_PATH, or add `idb` to PATH. For simulator tests ensure a simulator is booted.
-
-Environment variables
-
-- RUN_DEVICE_TESTS=true  — enable device tests when running the integration runner
-- ADB_PATH — custom path to adb (optional)
-- MCP_IDB_PATH / IDB_PATH — path to idb CLI (optional)
-- DEVICE_ID — when a test requires a device id
-- APP_ID — when a test requires an app package/bundle id (used by some scripts)
-
-How to run
-
-- Run all non-device integration tests (default):
-  npm run test:integration
-
-- Run device tests (all):
-  RUN_DEVICE_TESTS=true npm run test:integration
-
-- Run a single device test (example: iOS UI tree):
-  npx tsx test/device/observe/test-ui-tree.ts ios booted
-
-- Run install integration for a project:
-  npx tsx test/device/manage/install.integration.ts /path/to/project [deviceId]
-
-iOS notes
-
-- If using idb_companion, prefer starting it bound to a UDID to reduce flakiness:
-  idb_companion --udid <UDID> &
-- Boot a simulator if needed:
-  xcrun simctl boot <UDID>
-
-Android notes
-
-- Ensure an emulator or device is connected (adb devices)
-- Some tests read DEVICE_ID or accept it as an argument
-
-CI recommendation
-
-Keep these tests gated behind RUN_DEVICE_TESTS and run them only on macOS runners (for iOS) or self-hosted runners with attached devices.

package/test/device/index.ts

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-// Device tests runner
-// This runner loads minimal utilities, and only imports the device tests when
-// RUN_DEVICE_TESTS=true to avoid running them in CI by default.
-
-import './utils/test-dist';
-
-(async () => {
-  if (process.env.RUN_DEVICE_TESTS === 'true') {
-    console.log('RUN_DEVICE_TESTS=true: running device integration tests');
-    await Promise.all([
-      import('./manage/install.integration'),
-      import('./manage/run-install-android'),
-      import('./manage/run-install-ios'),
-      import('./observe/logstream-real'),
-      import('./observe/test-ui-tree'),
-      import('./observe/wait_for_element_real'),
-      import('./interact/run-real-test'),
-      import('./interact/smoke-test')
-    ]);
-    console.log('Device integration imports complete');
-  } else {
-    console.log('Skipping device-dependent integration tests. Set RUN_DEVICE_TESTS=true to enable them.');
-  }
-})();
-
-console.log('Device tests runner ready');

package/test/device/utils/test-dist.ts

@@ -1,41 +0,0 @@
-import fs from 'fs/promises'
-import { listAndroidDevices } from '../../../dist/android/utils.js'
-import { getAndroidLogs, captureAndroidScreen } from '../../../dist/android.js'
-
-async function main() {
-  try {
-    console.log('Listing Android devices...')
-    const devices = await listAndroidDevices()
-    console.log('Devices:', JSON.stringify(devices, null, 2))
-
-    if (devices.length === 0) {
-      console.log('No Android devices found; aborting Android smoke test.')
-      return
-    }
-
-    const target = devices[0]
-    console.log('Using target device:', target.id)
-
-    console.log('Fetching logs (last 50 lines)...')
-    const logsRes = await getAndroidLogs(undefined, 50, target.id)
-    console.log(`Retrieved ${logsRes.logCount} log lines`)
-    if (logsRes.logs && logsRes.logs.length > 0) {
-      console.log('Sample log:', logsRes.logs[Math.max(0, logsRes.logs.length - 1)].substring(0, 200))
-    }
-
-    console.log('Capturing screenshot...')
-    const shot = await captureAndroidScreen(target.id)
-    if (shot && shot.screenshot) {
-      const file = `smoke-test-android-${target.id}.png`
-      await fs.writeFile(file, Buffer.from(shot.screenshot, 'base64'))
-      console.log('Screenshot saved to', file)
-    } else {
-      console.log('No screenshot returned')
-    }
-  } catch {
-    console.error('Smoke test script failed:', err)
-    process.exit(1)
-  }
-}
-
-main()

package/test/unit/utils/detect-java.test.ts

@@ -1,22 +0,0 @@
-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: set JAVA_HOME to a fake path and ensure detectJavaHome still runs without throwing.
-  const orig = process.env.JAVA_HOME
-  process.env.JAVA_HOME = '/non/existent/java/home'
-  await detectJavaHome()
-  // accept either undefined or string results depending on environment; do not fail deterministically
-  process.env.JAVA_HOME = orig
-
-  console.log('detectJavaHome tests passed')
-}
-
-run().catch((e) => { console.error(e); process.exit(1) })