mobile-debug-mcp 0.30.2 → 0.31.0

package/src/utils/android/utils.ts

@@ -20,8 +20,10 @@ function findInPath(cmd: string): string | null {
 }
 
 export function resolveAdbCmd(): string {
-  // Priority: explicit env ADB_PATH -> ANDROID_SDK_ROOT/platform-tools/adb -> ANDROID_HOME/platform-tools/adb -> ~/Library/Android/sdk/platform-tools/adb -> PATH discovery -> 'adb'
+  // Priority: explicit env ADB_PATH -> PATH -> known SDK locations -> fallback to 'adb'
   if (process.env.ADB_PATH && process.env.ADB_PATH.trim()) return process.env.ADB_PATH
+  const found = findInPath('adb')
+  if (found) return found
   const sdkRoot = process.env.ANDROID_SDK_ROOT || process.env.ANDROID_HOME
   if (sdkRoot) {
     const candidate = path.join(sdkRoot, 'platform-tools', process.platform === 'win32' ? 'adb.exe' : 'adb')
@@ -30,8 +32,6 @@ export function resolveAdbCmd(): string {
   // common macOS user SDK path
   const homeSdk = path.join(process.env.HOME || '', 'Library', 'Android', 'sdk', 'platform-tools', process.platform === 'win32' ? 'adb.exe' : 'adb')
   if (existsSync(homeSdk)) return homeSdk
-  const found = findInPath('adb')
-  if (found) return found
   return 'adb'
 }
 

package/src/utils/cli/idb/check-idb.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { execSync, spawnSync } from 'child_process'
 import { main as installMain } from './install-idb.js'
-import { getIdbCmd, isIDBInstalled } from './idb-helper.js'
+import { getIdbCmd, getIdbPackageVersion, isIDBInstalled } from './idb-helper.js'
 
 function which(cmd: string): string | null {
   try {
@@ -48,7 +48,16 @@ try {
   const idb = process.env.IDB_PATH || getIdbCmd()
   print('idb:', idb)
   if (idb && isIDBInstalled()) {
-    try { print('idb --version:', execSync(`${idb} --version`, { stdio: ['ignore','pipe','ignore'] }).toString().trim()) } catch (e) { print('idb --version: (failed)', e instanceof Error ? e.message : String(e)) }
+    const version = getIdbPackageVersion()
+    if (version) print('fb-idb version:', version)
+    try {
+      const output = execSync(`${idb} list-targets --json`, { stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000 }).toString().trim()
+      print('idb list-targets --json: ok')
+      if (output) print(output)
+    } catch (e) {
+      print('idb list-targets --json: (failed)', e instanceof Error ? e.message : String(e))
+      process.exit(2)
+    }
     const companion = which('idb_companion')
     print('which idb_companion:', companion)
     if (companion) try { print('idb_companion --version:', execSync('idb_companion --version', { stdio: ['ignore','pipe','ignore'] }).toString().trim()) } catch (e) { print('idb_companion --version: (failed)', e instanceof Error ? e.message : String(e)) }

package/src/utils/cli/idb/idb-helper.ts

@@ -59,17 +59,54 @@ export function getIdbCmd(): string | null {
   return null
 }
 
-export function isIDBInstalled(): boolean {
-  const cmd = getIdbCmd()
-  if (!cmd) return false
-  try {
-    // command -v <cmd>
-    const r = spawnSync('command', ['-v', cmd], { stdio: ['ignore', 'pipe', 'ignore'] })
-    if (r && r.status === 0) return true
-  } catch {}
+export function getIdbPackageVersion(): string | null {
+  const runners = ['python3', 'python']
+  for (const runner of runners) {
+    try {
+      const result = spawnSync(runner, ['-m', 'pip', 'show', 'fb-idb'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+      })
+      if (result.status !== 0) continue
+      const output = `${result.stdout || ''}\n${result.stderr || ''}`
+      const match = output.match(/^Version:\s*(.+)$/mi)
+      if (match?.[1]) return match[1].trim()
+    } catch {
+      continue
+    }
+  }
+  return null
+}
+
+export function probeIdb(cmd = getIdbCmd()): { ok: boolean; raw: string | null; parsedVersion: string | null } {
+  if (!cmd) return { ok: false, raw: null, parsedVersion: null }
+
   try {
-    execSync(`${cmd} list-targets --json`, { stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000 })
-    return true
-  } catch {}
-  return false
+    const result = spawnSync(cmd, ['list-targets', '--json'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 5000
+    })
+    if (result.status !== 0) {
+      return {
+        ok: false,
+        raw: `${result.stdout || ''}${result.stderr || ''}`.trim() || null,
+        parsedVersion: null
+      }
+    }
+
+    const version = getIdbPackageVersion()
+    const raw = version ? `fb-idb ${version}` : `${result.stdout || ''}${result.stderr || ''}`.trim() || null
+    return {
+      ok: true,
+      raw,
+      parsedVersion: version
+    }
+  } catch {
+    return { ok: false, raw: null, parsedVersion: null }
+  }
+}
+
+export function isIDBInstalled(): boolean {
+  return probeIdb().ok
 }

package/src/utils/ios/utils.ts

@@ -59,17 +59,13 @@ export function getIdbCmd() {
 
 export async function isIDBInstalled(): Promise<boolean> {
   const cmd = getIdbCmd()
+  if (!cmd) return false
   try {
-    execSync(`command -v ${cmd}`, { stdio: ['ignore','pipe','ignore'] })
+    execSync(`${cmd} list-targets --json`, { stdio: ['ignore','pipe','pipe'], timeout: 5000 })
     return true
   } catch (e: unknown) {
-    try {
-      execSync(`${cmd} list-targets --json`, { stdio: ['ignore','pipe','ignore'], timeout: 2000 })
-      return true
-    } catch (e2: unknown) {
-      console.debug(`[isIDBInstalled] idb presence check failed for '${cmd}': ${e instanceof Error ? e.message : String(e2)}`)
-      return false
-    }
+    console.debug(`[isIDBInstalled] idb probe failed for '${cmd}': ${e instanceof Error ? e.message : String(e)}`)
+    return false
   }
 }
 

package/test/unit/interact/tap_element.test.ts

@@ -226,7 +226,7 @@ async function run() {
       const result = await ToolsInteract.waitForUIHandler({
         selector: { text: `Button ${i}` },
         condition: 'exists',
-        timeout_ms: 200,
+        timeout_ms: 1000,
         poll_interval_ms: 50,
         platform: 'android'
       })

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

@@ -9,6 +9,9 @@ async function run() {
   assert(typeof (payload as any).status === 'string')
   assert(Array.isArray(payload.issues))
   assert((payload as any).summary && typeof (payload as any).summary.overall === 'string')
+  assert((payload as any).host && typeof (payload as any).host.os === 'string')
+  assert((payload as any).android && typeof (payload as any).android.status === 'string')
+  assert((payload as any).ios && typeof (payload as any).ios.status === 'string')
 
   const adb = ensureAdbAvailable()
   assert(adb && typeof adb.ok === 'boolean')

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

@@ -74,6 +74,7 @@ async function run() {
     XCRUN_VERSION_OUTPUT: process.env.XCRUN_VERSION_OUTPUT,
     XCRUN_VERSION_STATUS: process.env.XCRUN_VERSION_STATUS,
     SIMCTL_LIST_OUTPUT: process.env.SIMCTL_LIST_OUTPUT,
+    MOBILE_DEBUG_MCP_HOST_OS: process.env.MOBILE_DEBUG_MCP_HOST_OS,
   }
 
   try {
@@ -82,6 +83,7 @@ async function run() {
     process.env.XCRUN_PATH = xcrunPath
 
     setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'darwin',
       ADB_VERSION_STATUS: '0',
       ADB_VERSION_OUTPUT: '8.1.0\n',
       ADB_DEVICES_OUTPUT: 'List of devices attached\nemulator-5554\tdevice product:sdk\n',
@@ -94,12 +96,16 @@ async function run() {
     const healthy = await systemStatus.getSystemStatus()
     assert.strictEqual(healthy.success, true)
     assert.strictEqual((healthy as any).status, 'ready')
+    assert.strictEqual((healthy as any).host.supported, true)
     assert.strictEqual(healthy.adbAvailable, true)
     assert.strictEqual(typeof healthy.adbVersion, 'string')
+    assert.strictEqual((healthy as any).android.status, 'ready')
+    assert.strictEqual((healthy as any).ios.status, 'ready')
     assert.strictEqual((healthy as any).summary.android.ready, true)
     assert.strictEqual(typeof (healthy as any).summary.ios.summary, 'string')
 
     setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'darwin',
       ADB_VERSION_STATUS: '1',
       ADB_VERSION_OUTPUT: 'not found',
       ADB_DEVICES_OUTPUT: 'List of devices attached\n',
@@ -112,6 +118,7 @@ async function run() {
     assert(missingAdb.issues.some((issue: string) => issue.includes('ADB')))
 
     setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'darwin',
       ADB_VERSION_STATUS: '0',
       ADB_VERSION_OUTPUT: '8.1.0\n',
       ADB_DEVICES_OUTPUT: 'List of devices attached\nserial1\tunauthorized\nserial2\toffline\n',
@@ -125,6 +132,7 @@ async function run() {
     assert(unauthorized.issues.some((issue: string) => issue.includes('offline')))
 
     setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'darwin',
       ADB_VERSION_STATUS: '0',
       ADB_VERSION_OUTPUT: '8.1.0\n',
       ADB_DEVICES_OUTPUT: 'List of devices attached\nemulator-5554\tdevice product:sdk\n',
@@ -136,6 +144,38 @@ async function run() {
     assert.strictEqual(missingXcrun.adbAvailable, true)
     assert.strictEqual(Array.isArray(missingXcrun.issues), true)
     assert.strictEqual((missingXcrun as any).summary.ios.ready, false)
+    assert.strictEqual((missingXcrun as any).ios.status, 'unavailable')
+
+    setScenario({
+      MOBILE_DEBUG_MCP_HOST_OS: 'win32',
+      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 windowsHost = await systemStatus.getSystemStatus()
+    assert.strictEqual((windowsHost as any).host.os, 'windows')
+    assert.strictEqual((windowsHost as any).host.supported, true)
+    assert.strictEqual((windowsHost as any).ios.status, 'unsupported')
+    assert.deepStrictEqual((windowsHost as any).ios.tools, {})
+    assert.deepStrictEqual((windowsHost as any).ios.providers, {})
+    assert.deepStrictEqual((windowsHost as any).ios.capabilities, {})
+    assert.deepStrictEqual((windowsHost as any).ios.devices, [])
+    assert.strictEqual((windowsHost as any).ios.failures[0].code, 'PLATFORM_UNAVAILABLE')
+    assert.strictEqual((windowsHost as any).summary.ios.ready, false)
+
+    setScenario({ MOBILE_DEBUG_MCP_HOST_OS: 'freebsd' })
+    const unsupported = await systemStatus.getSystemStatus()
+    assert.strictEqual((unsupported as any).host.os, 'freebsd')
+    assert.strictEqual((unsupported as any).host.supported, false)
+    assert.strictEqual((unsupported as any).android.status, 'unsupported')
+    assert.strictEqual((unsupported as any).ios.status, 'unsupported')
+    assert.strictEqual((unsupported as any).android.failures[0].code, 'HOST_OS_UNSUPPORTED')
+    assert.strictEqual((unsupported as any).ios.failures[0].code, 'HOST_OS_UNSUPPORTED')
+    assert.strictEqual(unsupported.adbAvailable, false)
+    assert.strictEqual(unsupported.iosAvailable, false)
+    assert.strictEqual((unsupported as any).summary.overall, 'blocked')
 
     console.log('system_status checks passed')
   } finally {

package/test/unit/utils/idb_health.test.ts

@@ -0,0 +1,74 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+
+import { isIDBInstalled, probeIdb } from '../../../src/utils/cli/idb/idb-helper.js'
+
+async function run() {
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-idb-health-'))
+  const idbPath = path.join(binDir, 'idb')
+  const python3Path = path.join(binDir, 'python3')
+  const pythonPath = path.join(binDir, 'python')
+  const pythonLog = path.join(binDir, 'python.log')
+  const originalIdbPath = process.env.MCP_IDB_PATH
+  const originalPath = process.env.PATH
+
+  try {
+    await fs.writeFile(idbPath, `#!/bin/sh
+if [ "$1" = "list-targets" ] && [ "$2" = "--json" ]; then
+  printf '{"targets":[]}\n'
+  exit 0
+fi
+if [ "$1" = "--version" ]; then
+  printf 'idb: error: unrecognized arguments: --version\n' >&2
+  exit 2
+fi
+exit 0
+`, { mode: 0o755 })
+
+    await fs.writeFile(python3Path, `#!/bin/sh
+printf 'python3 called\\n' >> "${pythonLog}"
+exit 0
+`, { mode: 0o755 })
+
+    await fs.writeFile(pythonPath, `#!/bin/sh
+printf 'python called\\n' >> "${pythonLog}"
+exit 0
+`, { mode: 0o755 })
+
+    process.env.MCP_IDB_PATH = idbPath
+    process.env.PATH = `${binDir}${path.delimiter}${originalPath || ''}`
+
+    const probe = probeIdb(idbPath)
+    assert.strictEqual(probe.ok, true)
+    assert.strictEqual(isIDBInstalled(), true)
+    assert(probe.raw === null || typeof probe.raw === 'string')
+
+    await fs.rm(pythonLog, { force: true }).catch(() => {})
+    const failedIdbPath = path.join(binDir, 'idb-failing')
+    await fs.writeFile(failedIdbPath, `#!/bin/sh
+if [ "$1" = "list-targets" ] && [ "$2" = "--json" ]; then
+  printf 'idb unavailable\\n' >&2
+  exit 2
+fi
+exit 2
+`, { mode: 0o755 })
+
+    const failureProbe = probeIdb(failedIdbPath)
+    assert.strictEqual(failureProbe.ok, false)
+    assert.strictEqual(await fs.readFile(pythonLog, 'utf8').catch(() => ''), '')
+
+    console.log('idb health probe test passed')
+  } finally {
+    if (originalIdbPath === undefined) delete process.env.MCP_IDB_PATH
+    else process.env.MCP_IDB_PATH = originalIdbPath
+
+    if (originalPath === undefined) delete process.env.PATH
+    else process.env.PATH = originalPath
+
+    await fs.rm(binDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+run().catch((error) => { console.error(error); process.exit(1) })