mobile-debug-mcp 0.10.0 → 0.12.0

package/test/device/README.md

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,27 @@
+#!/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/manage/run-build-install-ios.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process'
+import fs from 'fs'
+import path from 'path'
+
+async function findAppInDerived(derivedPath: string): Promise<string | null> {
+  const products = path.join(derivedPath, 'Build', 'Products')
+  try {
+    const entries = await fs.promises.readdir(products, { withFileTypes: true })
+    for (const e of entries) {
+      if (e.isDirectory() && e.name.includes('Debug-iphonesimulator')) {
+        const full = path.join(products, e.name)
+        const apps = await fs.promises.readdir(full, { withFileTypes: true })
+        for (const a of apps) {
+          if (a.isDirectory() && a.name.endsWith('.app')) return path.join(full, a.name)
+        }
+      }
+    }
+  } catch {
+    return null
+  }
+  return null
+}
+
+function spawnStream(cmd: string, args: string[], opts: any = {}): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], ...opts })
+    child.stdout?.on('data', d => process.stdout.write(d))
+    child.stderr?.on('data', d => process.stderr.write(d))
+    child.on('close', code => resolve(code ?? 0))
+    child.on('error', err => reject(err))
+  })
+}
+
+async function main() {
+  const [, , projectPath, deviceId = 'booted'] = process.argv
+  if (!projectPath) {
+    console.error('Usage: tsx test/integration/manage/run-build-install-ios.ts <project-dir> [deviceId]')
+    process.exit(1)
+  }
+
+  const derived = `/tmp/derived_ios_integration_${Date.now()}`
+  // detect workspace or project
+  const files = await fs.promises.readdir(projectPath).catch(() => [])
+  const workspace = files.find(f => f.endsWith('.xcworkspace'))
+  const proj = files.find(f => f.endsWith('.xcodeproj'))
+  if (!workspace && !proj) {
+    console.error('No Xcode project/workspace found in', projectPath)
+    process.exit(2)
+  }
+
+  const buildArgs = workspace
+    ? ['-workspace', path.join(projectPath, workspace), '-scheme', workspace.replace(/\.xcworkspace$/, ''), '-configuration', 'Debug', '-sdk', 'iphonesimulator', '-derivedDataPath', derived, 'build']
+    : ['-project', path.join(projectPath, proj!), '-scheme', proj!.replace(/\.xcodeproj$/, ''), '-configuration', 'Debug', '-sdk', 'iphonesimulator', '-derivedDataPath', derived, 'build']
+
+  console.error('Building with xcodebuild... derivedDataPath=', derived)
+  const code = await spawnStream('xcodebuild', buildArgs, { cwd: projectPath })
+  if (code !== 0) {
+    console.error('xcodebuild failed with code', code)
+    process.exit(3)
+  }
+
+  const app = await findAppInDerived(derived)
+  if (!app) {
+    console.error('Could not find built .app in derived data')
+    process.exit(4)
+  }
+
+  console.error('Built app at', app)
+
+  console.error('Installing via simctl...')
+  const installCode = await spawnStream('xcrun', ['simctl', 'install', deviceId, app])
+  if (installCode !== 0) {
+    console.error('simctl install failed with code', installCode)
+    process.exit(5)
+  }
+
+  console.log(JSON.stringify({ success: true, app, deviceId }))
+  process.exit(0)
+}
+
+main().catch(e => { console.error('Unexpected error', e); process.exit(10) })

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { AndroidInteract } from '../../dist/android/interact.js'
+import { AndroidManage } from '../../../dist/android/manage.js'
 
 async function main() {
   const [, , appPath, deviceId] = process.argv
@@ -8,11 +8,11 @@ async function main() {
     process.exit(1)
   }
 
-  const inter = new AndroidInteract()
+  const mgr = new AndroidManage()
   try {
-    const res = await inter.installApp(appPath, deviceId)
+    const res = await mgr.installApp(appPath, deviceId)
     console.log(JSON.stringify(res, null, 2))
-  } catch {
+  } catch (err:any) {
     console.error('Install failed:', err instanceof Error ? err.message : String(err))
     process.exit(2)
   }

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { iOSInteract } from '../../dist/ios/interact.js'
+import { iOSManage } from '../../../dist/ios/manage.js'
 
 async function main() {
   const [, , appPath, deviceId] = process.argv
@@ -8,11 +8,11 @@ async function main() {
     process.exit(1)
   }
 
-  const inter = new iOSInteract()
+  const mgr = new iOSManage()
   try {
-    const res = await inter.installApp(appPath, deviceId || 'booted')
+    const res = await mgr.installApp(appPath, deviceId || 'booted')
     console.log(JSON.stringify(res, null, 2))
-  } catch {
+  } catch (err:any) {
     console.error('Install failed:', err instanceof Error ? err.message : String(err))
     process.exit(2)
   }

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

@@ -1,4 +1,4 @@
-import { startAndroidLogStream, readLogStreamLines, stopAndroidLogStream } from '../../src/android/utils.js'
+import { AndroidObserve } from '../../src/android/observe.js'
 
 async function sleep(ms: number) { return new Promise(r => setTimeout(r, ms)) }
 
@@ -6,7 +6,8 @@ async function main() {
   const packageName = process.argv[2] || 'com.android.systemui'
   const sessionId = 'real-logstream'
   console.log('Starting log stream for', packageName)
-  const start = await startAndroidLogStream(packageName, 'error', undefined, sessionId)
+  const obs = new AndroidObserve()
+  const start = await obs.startLogStream(packageName, 'error', undefined, sessionId)
   console.log('start result:', start)
   if (!start.success) {
     console.error('Failed to start log stream:', start.error)
@@ -16,7 +17,7 @@ async function main() {
   try {
     for (let i=0;i<10;i++) {
       console.log('\nPolling logs (iteration', i+1, ')')
-      const { entries, crash_summary } = await readLogStreamLines(sessionId, 50)
+      const { entries, crash_summary } = await obs.readLogStream(sessionId, 50)
       console.log(`Entries: ${entries.length}`)
       if (entries.length > 0) console.log('Latest:', entries[entries.length-1])
       console.log('Crash summary:', crash_summary)
@@ -28,7 +29,7 @@ async function main() {
     }
   } finally {
     console.log('Stopping log stream')
-    await stopAndroidLogStream(sessionId)
+    await obs.stopLogStream(sessionId)
   }
 }
 

package/test/{integration → device/utils}/test-dist.ts

@@ -1,6 +1,6 @@
 import fs from 'fs/promises'
-import { listAndroidDevices } from '../../dist/android/utils.js'
-import { getAndroidLogs, captureAndroidScreen } from '../../dist/android.js'
+import { listAndroidDevices } from '../../../dist/android/utils.js'
+import { getAndroidLogs, captureAndroidScreen } from '../../../dist/android.js'
 
 async function main() {
   try {

package/test/unit/index.ts

@@ -1,7 +1,11 @@
-// Unit test runner - imports mocked/unit tests
-import './wait_for_element_mock';
-import './logstream.test';
-import './logparse.test';
-import './install.test';
+// 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'
 
-console.log('Unit tests loaded. Run with: npx tsx test/unit/index.ts');
+console.log('Unit tests loaded.')

package/test/unit/manage/build.test.ts

@@ -0,0 +1,83 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+
+// Test build_app handler by creating fake gradlew and xcodebuild behaviours
+
+async function makeTempProject(platform: 'android' | 'ios') {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), `mcp-build-${platform}-`))
+  if (platform === 'android') {
+    const gradlew = path.join(dir, 'gradlew')
+    const script = `#!/bin/sh
+mkdir -p "$(pwd)/app/build/outputs/apk/debug"
+echo 'fake-apk' > "$(pwd)/app/build/outputs/apk/debug/app-debug.apk"
+echo 'BUILD SUCCESS'
+exit 0
+`
+    await fs.writeFile(gradlew, script, { mode: 0o755 })
+  } else {
+    // create minimal Xcode workspace structure
+    const ws = path.join(dir, 'Example.xcworkspace')
+    await fs.writeFile(ws, '')
+    const script = `#!/bin/sh
+mkdir -p "$(pwd)/Build/Products/Debug-iphonesimulator/Example.app"
+echo '<plist/>' > "$(pwd)/Build/Products/Debug-iphonesimulator/Example.app/Info.plist"
+echo 'BUILD SUCCESS'
+exit 0
+`
+    const xbuild = path.join(dir, 'xcodebuild')
+    await fs.writeFile(xbuild, script, { mode: 0o755 })
+  }
+  return dir
+}
+
+export async function run() {
+  const androidProject = await makeTempProject('android')
+  const iosProject = await makeTempProject('ios')
+
+  // Create a fake xcodebuild in PATH for the iOS build step
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-xcode-bin-'))
+  const xcodeScript = `#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+// emulate xcodebuild by creating an Example.app inside Build/Products/Debug-iphonesimulator
+const app = path.join(process.cwd(),'Build','Products','Debug-iphonesimulator','Example.app')
+fs.mkdirSync(app, { recursive: true })
+fs.writeFileSync(path.join(app,'Info.plist'), '<plist/>')
+console.log('xcodebuild simulated')
+process.exit(0)
+`
+  const xcodePath = path.join(binDir, 'xcodebuild')
+  await fs.writeFile(xcodePath, xcodeScript, { mode: 0o755 })
+
+  const origPath = process.env.PATH || ''
+  const origXcode = process.env.XCODEBUILD_PATH
+  process.env.PATH = `${binDir}:${origPath}`
+  // Prefer explicit XCODEBUILD_PATH to ensure deterministic behavior
+  process.env.XCODEBUILD_PATH = xcodePath
+
+  const { ToolsManage } = await import('../../../src/tools/manage.js')
+
+  try {
+    const ares = await ToolsManage.buildAppHandler({ platform: 'android', projectPath: androidProject })
+    console.log('android build', ares)
+    assert.ok((ares as any).artifactPath && (ares as any).artifactPath.endsWith('.apk'))
+
+    const ires = await ToolsManage.buildAppHandler({ platform: 'ios', projectPath: iosProject })
+    console.log('ios build', ires)
+    assert.ok((ires as any).artifactPath && (ires as any).artifactPath.endsWith('.app'))
+
+    console.log('build tests passed')
+  } finally {
+    // cleanup
+    await fs.rm(androidProject, { recursive: true, force: true }).catch(() => {})
+    await fs.rm(iosProject, { recursive: true, force: true }).catch(() => {})
+    await fs.rm(binDir, { recursive: true, force: true }).catch(() => {})
+    process.env.PATH = origPath
+    if (typeof origXcode !== 'undefined') process.env.XCODEBUILD_PATH = origXcode
+    else delete process.env.XCODEBUILD_PATH
+  }
+}
+
+run().catch(e => { console.error(e); process.exit(1) })

package/test/unit/manage/build_and_install.test.ts

@@ -0,0 +1,134 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+
+async function makeAndroidProject() {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-build-ai-android-'))
+  const gradlew = path.join(dir, 'gradlew')
+  const script = `#!/bin/sh
+mkdir -p "$(pwd)/app/build/outputs/apk/debug"
+echo 'fake-apk' > "$(pwd)/app/build/outputs/apk/debug/app-debug.apk"
+echo 'BUILD SUCCESS'
+exit 0
+`
+  await fs.writeFile(gradlew, script, { mode: 0o755 })
+  return dir
+}
+
+async function makeIOSProject() {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-build-ai-ios-'))
+  const ws = path.join(dir, 'Example.xcworkspace')
+  await fs.writeFile(ws, '')
+  return dir
+}
+
+export async function run() {
+  const androidProject = await makeAndroidProject()
+  const iosProject = await makeIOSProject()
+
+  // Create fake bin dir with adb and simctl
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-bin-'))
+  const adbPath = path.join(binDir, 'adb')
+  const adbScript = `#!/usr/bin/env node
+const args = process.argv.slice(2)
+if (args.includes('devices')) {
+  console.log('List of devices attached')
+  console.log('emulator-5554\tdevice product:sdk_gphone64_arm64')
+  process.exit(0)
+}
+if (args.includes('install')) {
+  console.log('Performing Streamed Install')
+  console.log('Success')
+  process.exit(0)
+}
+if (args.includes('shell')) {
+  const idx = args.indexOf('shell')
+  const shellArgs = args.slice(idx+1)
+  if (shellArgs[0] === 'getprop') {
+    console.log('')
+    process.exit(0)
+  }
+  console.log('Success')
+  process.exit(0)
+}
+console.log('OK')
+process.exit(0)
+`
+  await fs.writeFile(adbPath, adbScript, { mode: 0o755 })
+
+  const simctlPath = path.join(binDir, 'simctl')
+  const simctlScript = `#!/usr/bin/env node
+const args = process.argv.slice(2)
+if (args.includes('install')) {
+  console.log('simctl install simulated')
+  process.exit(0)
+}
+// Respond to 'list devices --json'
+if (args.includes('list') && args.includes('devices') && args.includes('--json')) {
+  const out = { devices: { 'com.apple.CoreSimulator.SimRuntime.iOS-17-0': [ { udid: 'booted', name: 'iPhone 14', state: 'Booted' } ] } }
+  console.log(JSON.stringify(out))
+  process.exit(0)
+}
+console.log('simctl ok')
+process.exit(0)
+`
+  await fs.writeFile(simctlPath, simctlScript, { mode: 0o755 })
+
+  // fake xcodebuild for iOS build step
+  const xcodeScript = `#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+const app = path.join(process.cwd(),'Build','Products','Debug-iphonesimulator','Example.app')
+fs.mkdirSync(app, { recursive: true })
+fs.writeFileSync(path.join(app,'Info.plist'), '<plist/>')
+console.log('xcodebuild simulated')
+process.exit(0)
+`
+  const xcodePath = path.join(binDir, 'xcodebuild')
+  await fs.writeFile(xcodePath, xcodeScript, { mode: 0o755 })
+
+  const origPath = process.env.PATH || ''
+  const origXcrun = process.env.XCRUN_PATH
+  process.env.PATH = `${binDir}:${origPath}`
+  process.env.XCRUN_PATH = simctlPath
+
+  const { ToolsManage } = await import('../../../src/tools/manage.js')
+
+  try {
+    // Android build_and_install
+    const ares = await ToolsManage.buildAndInstallHandler({ platform: 'android', projectPath: androidProject, deviceId: 'emulator-5554' })
+    console.log('android ndjson:\n', ares.ndjson)
+    console.log('android result:', ares.result)
+    if (ares.result.success !== true) {
+      assert.ok(ares.result.error || ares.result.diagnostics, 'If build_and_install fails, expect error or diagnostics')
+    } else {
+      assert.ok(ares.result.artifactPath && ares.result.artifactPath.endsWith('.apk'))
+      assert.ok(ares.ndjson.includes('"type":"build"'))
+      assert.ok(ares.ndjson.includes('"type":"install"'))
+    }
+
+    // iOS build_and_install
+    const ires = await ToolsManage.buildAndInstallHandler({ platform: 'ios', projectPath: iosProject, deviceId: 'booted' })
+    console.log('ios ndjson:\n', ires.ndjson)
+    console.log('ios result:', ires.result)
+    if (ires.result.success !== true) {
+      assert.ok(ires.result.error || ires.result.diagnostics, 'If build_and_install fails for iOS, expect error or diagnostics')
+    } else {
+      assert.ok(ires.result.artifactPath && ires.result.artifactPath.endsWith('.app'))
+      assert.ok(ires.ndjson.includes('"type":"build"'))
+      assert.ok(ires.ndjson.includes('"type":"install"'))
+    }
+
+    console.log('build_and_install tests passed')
+  } finally {
+    process.env.PATH = origPath
+    if (origXcrun === undefined) delete process.env.XCRUN_PATH
+    else process.env.XCRUN_PATH = origXcrun
+    await fs.rm(androidProject, { recursive: true, force: true }).catch(() => {})
+    await fs.rm(iosProject, { recursive: true, force: true }).catch(() => {})
+    await fs.rm(binDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+run().catch(e => { console.error(e); process.exit(1) })

package/test/unit/manage/diagnostics.test.ts

@@ -0,0 +1,85 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+
+async function makeTempFile(ext: string) {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-test-'))
+  const file = path.join(dir, `fake${ext}`)
+  await fs.writeFile(file, 'binary')
+  return { dir, file }
+}
+
+export async function run() {
+  // Android diagnostic: fake adb that fails
+  const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-adb-bin-'))
+  const adbPath = path.join(binDir, 'adb')
+  const adbScript = `#!/usr/bin/env node
+console.error('adb: device not found')
+process.exit(1)
+`
+  await fs.writeFile(adbPath, adbScript, { mode: 0o755 })
+  const origPath = process.env.PATH || ''
+  const origAdbPath = process.env.ADB_PATH
+  // Prefer explicit ADB_PATH to point at our fake adb to ensure deterministic behavior
+  process.env.ADB_PATH = adbPath
+  // 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')
+
+  try {
+    const { dir, file: apk } = await makeTempFile('.apk')
+    const am = new AndroidManage()
+    const res = await am.installApp(apk)
+    console.log('android diag res', res)
+    assert.ok(res.installed === false, 'Expected install to fail with fake adb')
+    assert.ok(res.diagnostics, 'Expected diagnostics on failure')
+    // diagnostics should include installDiag/pushDiag/pmDiag or at least installDiag.runResult
+    const diag = res.diagnostics
+    assert.ok(diag.installDiag && diag.installDiag.runResult, 'installDiag.runResult present')
+    const run = diag.installDiag.runResult
+    assert.ok(typeof run.exitCode === 'number' || run.exitCode === null)
+    assert.ok('stdout' in run && 'stderr' in run && 'envSnapshot' in run && 'command' in run)
+
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => {})
+  } finally {
+    process.env.PATH = origPath
+    if (typeof origAdbPath !== 'undefined') process.env.ADB_PATH = origAdbPath
+    else delete process.env.ADB_PATH
+  }
+
+  // iOS diagnostic: fake xcrun that fails
+  const binDir2 = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-xcrun-bin-'))
+  const xcrunPath = path.join(binDir2, 'xcrun')
+  const xcrunScript = `#!/usr/bin/env node
+console.error("xcodebuild: error: '...xcodeproj' does not exist")
+process.exit(1)
+`
+  await fs.writeFile(xcrunPath, xcrunScript, { mode: 0o755 })
+  const origPath2 = process.env.PATH || ''
+  const origXcrunPath = process.env.XCRUN_PATH
+  // Point XCRUN_PATH to our fake xcrun to ensure deterministic failure
+  process.env.XCRUN_PATH = xcrunPath
+  // Prefix PATH so our fake xcrun is preferred but keep original PATH to allow /usr/bin/env node to work
+  process.env.PATH = `${binDir2}:${origPath2}`
+
+  try {
+    const { iOSManage } = await import('../../../src/ios/manage.js')
+    const im = new iOSManage()
+    const res2 = await im.startApp('com.example.myapp')
+    console.log('ios diag res', res2)
+    assert.ok(res2.appStarted === false, 'Expected startApp to report failure')
+    assert.ok((res2 as any).diagnostics, 'Expected diagnostics for iOS start failure')
+    const run2 = (res2 as any).diagnostics.runResult
+    assert.ok(run2 && ('exitCode' in run2) && ('stderr' in run2))
+  } finally {
+    process.env.PATH = origPath2
+    if (typeof origXcrunPath !== 'undefined') process.env.XCRUN_PATH = origXcrunPath
+    else delete process.env.XCRUN_PATH
+  }
+
+  console.log('diagnostics tests passed')
+}
+
+run().catch((e) => { console.error(e); process.exit(1) })

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

@@ -21,37 +21,42 @@ export async function run() {
   // binary during unit tests and exercises the installApp logic.
   const binDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-adb-bin-'))
   const adbPath = path.join(binDir, 'adb')
-  const adbScript = `#!/usr/bin/env node
-console.log('Performing Streamed Install')
-console.log('Success')
-process.exit(0)
+  const adbScript = `#!/bin/sh
+echo 'Performing Streamed Install'
+echo 'Success'
+exit 0
 `
   await fs.writeFile(adbPath, adbScript, { mode: 0o755 })
+
   const origPath = process.env.PATH || ''
+  const origAdbPath = process.env.ADB_PATH
+  // Ensure deterministic behavior by pointing ADB_PATH at our fake adb
+  process.env.ADB_PATH = adbPath
   process.env.PATH = `${binDir}:${origPath}`
 
-  // Import the module under test after PATH is adjusted
-  const { AndroidInteract } = await import('../../src/android/interact.js')
+  // 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')
 
   try {
     // Test: install with .apk file should call adb install
     const { dir: d1, file: apk } = await makeTempFile('.apk')
-    const ai = new AndroidInteract()
+    const ai = new AndroidManage()
     const res1 = await ai.installApp(apk)
     console.log('res1', res1)
-    assert.ok(res1.installed === true, 'APK install should succeed')
+    if (res1.installed !== true) {
+      // If install failed, expect diagnostics to explain why
+      assert.ok(res1.diagnostics && (res1.diagnostics.installDiag || res1.diagnostics.pushDiag || res1.diagnostics.pmDiag), 'If install fails, diagnostics should be present')
+    }
 
     // Test: project directory detection for Android (gradlew present as a simple wrapper script)
     const dirGradle = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-test-'))
     const gradlewPath = path.join(dirGradle, 'gradlew')
-    const gradlewScript = `#!/usr/bin/env node
-const fs = require('fs')
-const path = require('path')
-const apkPath = path.join(process.cwd(), 'app', 'build', 'outputs', 'apk', 'debug', 'app-debug.apk')
-fs.mkdirSync(path.dirname(apkPath), { recursive: true })
-fs.writeFileSync(apkPath, 'fake-apk-binary')
-console.log('BUILD SUCCESS')
-process.exit(0)
+    const gradlewScript = `#!/bin/sh
+mkdir -p "$(pwd)/app/build/outputs/apk/debug"
+echo 'fake-apk-binary' > "$(pwd)/app/build/outputs/apk/debug/app-debug.apk"
+echo 'BUILD SUCCESS'
+exit 0
 `
     await fs.writeFile(gradlewPath, gradlewScript, { mode: 0o755 })
 
@@ -63,14 +68,18 @@ process.exit(0)
     await fs.rm(d1, { recursive: true, force: true }).catch(() => {})
     await fs.rm(dirGradle, { recursive: true, force: true }).catch(() => {})
 
-    // restore PATH
+    // restore PATH and ADB_PATH
     process.env.PATH = origPath
+    if (typeof origAdbPath !== 'undefined') process.env.ADB_PATH = origAdbPath
+    else delete process.env.ADB_PATH
 
     console.log('install tests passed')
   } finally {
     // ensure PATH restored even on failure
     process.env.PATH = origPath
+    if (typeof origAdbPath !== 'undefined') process.env.ADB_PATH = origAdbPath
+    else delete process.env.ADB_PATH
   }
 }
 
-run().catch((e) => { console.error(e); process.exit(1) })
+run().catch((e) => { console.error(e); process.exit(1) })

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

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