mobile-debug-mcp 0.32.2 → 0.33.0

package/src/observe/android-tree-bridge.ts

@@ -1,178 +0,0 @@
-import { execFile, spawn, spawnSync, type ChildProcess } from 'node:child_process'
-import { existsSync } from 'node:fs'
-import { connect } from 'node:net'
-import path from 'node:path'
-import { execAdb, getAdbCmd } from '../utils/android/utils.js'
-import { remainingBudget } from '../utils/operation-budget.js'
-
-const packageName = 'dev.mobiledebugmcp.treebridge'
-const component = `${packageName}/.TreeInstrumentation`
-const devicePort = 39019
-
-interface Bridge {
-  deviceId: string
-  hostPort: number
-  child: ChildProcess
-  closed: boolean
-  childClosed: boolean
-}
-
-const active = new Map<string, Bridge>()
-const starting = new Map<string, Promise<Bridge>>()
-const stopping = new Map<string, Promise<void>>()
-const bridgeSupport = new Map<string, boolean>()
-
-export function androidTreeBridgeEnabled(): boolean {
-  return Boolean(process.env.MOBILE_DEBUG_MCP_ANDROID_TREE_BRIDGE_APK)
-}
-
-function configuredApk() {
-  const configured = process.env.MOBILE_DEBUG_MCP_ANDROID_TREE_BRIDGE_APK
-  if (!configured) return null
-  const apk = path.resolve(configured)
-  if (!existsSync(apk)) throw new Error(`Android UI tree bridge APK does not exist: ${apk}`)
-  return apk
-}
-
-function unbudgetedAdb(deviceId: string, args: string[]): Promise<void> {
-  return new Promise((resolve, reject) => {
-    execFile(getAdbCmd(), ['-s', deviceId, ...args], { timeout: 5000 }, (error) => error ? reject(error) : resolve())
-  })
-}
-
-function request(bridge: Bridge, command: 'PING' | 'TREE' | 'STOP', timeoutMs: number): Promise<string> {
-  return new Promise((resolve, reject) => {
-    let output = ''
-    const socket = connect(bridge.hostPort, '127.0.0.1', () => socket.write(`${command}\n`))
-    socket.setTimeout(timeoutMs, () => socket.destroy(new Error(`Android UI tree bridge ${command} timed out`)))
-    socket.on('data', (chunk) => {
-      output += chunk.toString()
-      if (command === 'STOP' && output.startsWith('OK\n')) {
-        resolve(output)
-        socket.destroy()
-      }
-    })
-    socket.on('error', reject)
-    socket.on('end', () => resolve(output))
-  })
-}
-
-function waitForChildClose(bridge: Bridge, timeoutMs: number): Promise<void> {
-  if (bridge.childClosed) return Promise.resolve()
-  return new Promise((resolve, reject) => {
-    const onClose = () => { clearTimeout(timer); resolve() }
-    const timer = setTimeout(() => {
-      bridge.child.off('close', onClose)
-      reject(new Error('Android UI tree bridge child did not exit'))
-    }, timeoutMs)
-    bridge.child.once('close', onClose)
-  })
-}
-
-async function stop(bridge: Bridge): Promise<void> {
-  const pending = stopping.get(bridge.deviceId)
-  if (pending) return pending
-  bridge.closed = true
-  const cleanup = (async () => {
-    await request(bridge, 'STOP', 1000).catch(() => '')
-    let forceStopError: unknown
-    try { await unbudgetedAdb(bridge.deviceId, ['shell', 'am', 'force-stop', packageName]) }
-    catch (error) { forceStopError = error }
-    try { await waitForChildClose(bridge, 1000) }
-    catch {
-      bridge.child.kill('SIGTERM')
-      try { await waitForChildClose(bridge, 1000) }
-      catch {
-        bridge.child.kill('SIGKILL')
-        await waitForChildClose(bridge, 2000).catch(() => {})
-      }
-    }
-    let forwardError: unknown
-    try { await unbudgetedAdb(bridge.deviceId, ['forward', '--remove', `tcp:${bridge.hostPort}`]) }
-    catch (error) { forwardError = error }
-    if (forceStopError || !bridge.childClosed || forwardError) {
-      const reason = forceStopError ?? (!bridge.childClosed ? 'instrumentation child did not close' : forwardError)
-      throw new Error(`BRIDGE_CLEANUP_UNCONFIRMED: ${reason instanceof Error ? reason.message : String(reason)}`)
-    }
-    if (active.get(bridge.deviceId) === bridge) active.delete(bridge.deviceId)
-  })()
-  stopping.set(bridge.deviceId, cleanup)
-  try { await cleanup } finally { stopping.delete(bridge.deviceId) }
-}
-
-async function launch(deviceId: string, apk: string): Promise<Bridge> {
-  await unbudgetedAdb(deviceId, ['shell', 'am', 'force-stop', packageName])
-  try {
-    await execAdb(['install', '-r', apk], deviceId)
-  } catch (error) {
-    if (!(error instanceof Error) || !error.message.includes('INSTALL_FAILED_UPDATE_INCOMPATIBLE')) throw error
-    await execAdb(['uninstall', packageName], deviceId)
-    await execAdb(['install', '-r', apk], deviceId)
-  }
-  const hostPort = Number(await execAdb(['forward', 'tcp:0', `tcp:${devicePort}`], deviceId))
-  if (!Number.isInteger(hostPort) || hostPort <= 0) throw new Error('Android UI tree bridge could not obtain a host port')
-  const child = spawn(getAdbCmd(), ['-s', deviceId, 'shell', 'am', 'instrument', '-w', component], { stdio: 'ignore' })
-  const bridge: Bridge = { deviceId, hostPort, child, closed: false, childClosed: false }
-  child.once('close', () => { bridge.childClosed = true })
-  child.once('error', () => { /* Startup detects the failed child before a tree read. */ })
-  active.set(deviceId, bridge)
-  try {
-    const deadline = Date.now() + Math.min(remainingBudget(3000), 3000)
-    while (Date.now() < deadline) {
-      if (bridge.childClosed || child.exitCode !== null || child.signalCode !== null) throw new Error('Android UI tree bridge exited during startup')
-      try {
-        if ((await request(bridge, 'PING', 250)).startsWith('OK\n')) {
-          return bridge
-        }
-      } catch { /* The instrumentation process may still be starting. */ }
-      await new Promise((resolve) => setTimeout(resolve, 100))
-    }
-    throw new Error('Android UI tree bridge did not become ready')
-  } catch (error) {
-    await stop(bridge)
-    throw error
-  }
-}
-
-async function ensure(deviceId: string, apk: string): Promise<Bridge> {
-  const pending = starting.get(deviceId)
-  if (pending) return pending
-  const ready = active.get(deviceId)
-  if (ready && !ready.closed && !ready.childClosed && ready.child.exitCode === null && ready.child.signalCode === null) return ready
-  if (ready) await stop(ready)
-  const promise = launch(deviceId, apk)
-  starting.set(deviceId, promise)
-  try { return await promise } finally { starting.delete(deviceId) }
-}
-
-/** Returns null only after the bridge has been stopped, so legacy acquisition is safe. */
-export async function readAndroidTreeFromBridge(deviceId: string): Promise<string | null> {
-  const apk = configuredApk()
-  if (!apk) return null
-  let bridge: Bridge | undefined
-  try {
-    let supported = bridgeSupport.get(deviceId)
-    if (supported === undefined) {
-      const sdkLevel = Number(await execAdb(['shell', 'getprop', 'ro.build.version.sdk'], deviceId))
-      supported = Number.isInteger(sdkLevel) && sdkLevel >= 34
-      if (supported) bridgeSupport.set(deviceId, true)
-    }
-    if (!supported) return null
-    bridge = await ensure(deviceId, apk)
-    const output = await request(bridge, 'TREE', remainingBudget(10000))
-    if (!output.startsWith('OK\n') || !output.includes('<hierarchy')) throw new Error('Android UI tree bridge returned invalid hierarchy output')
-    return output.slice(3)
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith('BRIDGE_CLEANUP_UNCONFIRMED')) throw error
-    if (bridge) await stop(bridge)
-    if (error instanceof Error && error.message === 'ACTION_TIMEOUT') throw error
-    return null
-  }
-}
-
-process.once('exit', () => {
-  for (const bridge of active.values()) {
-    spawnSync(getAdbCmd(), ['-s', bridge.deviceId, 'shell', 'am', 'force-stop', packageName], { timeout: 2000, stdio: 'ignore' })
-    spawnSync(getAdbCmd(), ['-s', bridge.deviceId, 'forward', '--remove', `tcp:${bridge.hostPort}`], { timeout: 2000, stdio: 'ignore' })
-  }
-})

package/test/device/automated/ui-tree-performance/bridge-probe.ts

@@ -1,197 +0,0 @@
-import { execFileSync, spawn, type ChildProcess } from 'node:child_process'
-import { createServer } from 'node:http'
-import { connect } from 'node:net'
-import { mkdirSync, writeFileSync } from 'node:fs'
-import path from 'node:path'
-import { randomUUID } from 'node:crypto'
-import { XMLParser } from 'fast-xml-parser'
-import { buildBridge } from '../../../fixtures/ui-tree-bridge/build.js'
-import { buildFixture } from '../../../fixtures/latency-journey-app/build.js'
-import { summarize } from '../latency/report.js'
-
-const deviceId = process.env.LATENCY_DEVICE_ID ?? ''
-if (!deviceId) throw new Error('Set LATENCY_DEVICE_ID to one Android emulator')
-const bridgePackage = 'dev.mobiledebugmcp.treebridge'
-const fixturePackage = 'dev.mobiledebugmcp.latencyfixture'
-const hostPort = 39020
-const devicePort = 39019
-const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_' })
-const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
-const elapsedMs = (start: bigint) => Number(process.hrtime.bigint() - start) / 1e6
-const adb = (...args: string[]) => execFileSync('adb', ['-s', deviceId!, ...args], { encoding: 'utf8', timeout: 30000, stdio: ['ignore', 'pipe', 'pipe'] }).trim()
-
-function install(apk: string, appId: string) {
-  try { adb('install', '-r', apk) }
-  catch (error) {
-    if (!(error instanceof Error) || !error.message.includes('INSTALL_FAILED_UPDATE_INCOMPATIBLE')) throw error
-    adb('uninstall', appId)
-    adb('install', '-r', apk)
-  }
-}
-
-function nodes(xml: string): Array<Record<string, string>> {
-  const tree = parser.parse(xml)
-  const result: Array<Record<string, string>> = []
-  const visit = (item: any) => {
-    if (!item) return
-    if (Array.isArray(item)) return item.forEach(visit)
-    if (item['@_class']) result.push(item)
-    visit(item.node)
-  }
-  visit(tree.hierarchy)
-  return result
-}
-
-function bridgeRead(): Promise<{ xml: string; elapsed_ms: number; started_ns: bigint }> {
-  const started_ns = process.hrtime.bigint()
-  return new Promise((resolve, reject) => {
-    let output = ''
-    const socket = connect(hostPort, '127.0.0.1', () => socket.write('TREE\n'))
-    socket.setTimeout(10000, () => socket.destroy(new Error('Bridge read timed out')))
-    socket.on('data', (chunk) => { output += chunk.toString() })
-    socket.on('error', reject)
-    socket.on('end', () => {
-      if (!output.startsWith('OK\n') || !output.includes('<hierarchy')) return reject(new Error(`Bridge response failed: ${output.slice(0, 80)}`))
-      resolve({ xml: output.slice(3), elapsed_ms: elapsedMs(started_ns), started_ns })
-    })
-  })
-}
-
-async function readyBridge() {
-  const deadline = Date.now() + 10000
-  while (Date.now() < deadline) {
-    try { return await bridgeRead() } catch { await sleep(100) }
-  }
-  throw new Error('Bridge did not become ready')
-}
-
-async function stopBridge() {
-  await new Promise<void>((resolve, reject) => {
-    const socket = connect(hostPort, '127.0.0.1', () => socket.write('STOP\n'))
-    socket.setTimeout(5000, () => socket.destroy(new Error('Bridge stop timed out')))
-    socket.on('error', reject)
-    socket.on('data', (chunk) => {
-      if (chunk.toString().startsWith('OK\n')) {
-        socket.destroy()
-        resolve()
-      }
-    })
-  })
-}
-
-async function main() {
-  const bridgeApk = buildBridge()
-  const fixtureApk = buildFixture()
-  install(bridgeApk, bridgePackage)
-  install(fixtureApk, fixturePackage)
-  const runId = randomUUID()
-  let releaseResponse!: () => void
-  let requestSeen!: () => void
-  let responseSentNs = 0n
-  const requestPromise = new Promise<void>((resolve) => { requestSeen = resolve })
-  const releasePromise = new Promise<void>((resolve) => { releaseResponse = resolve })
-  const server = createServer(async (request, response) => {
-    const url = new URL(request.url ?? '/', 'http://localhost')
-    if (url.pathname !== '/data' || url.searchParams.get('run_id') !== runId) return response.writeHead(404).end()
-    requestSeen()
-    await releasePromise
-    await sleep(100)
-    responseSentNs = process.hrtime.bigint()
-    response.writeHead(200, { 'content-type': 'text/plain', 'cache-control': 'no-store' }).end(`${runId}|value-${runId}`)
-  })
-  await new Promise<void>((resolve, reject) => { server.once('error', reject); server.listen(0, '0.0.0.0', resolve) })
-  const address = server.address()
-  if (!address || typeof address === 'string') throw new Error('Fixture server did not bind')
-  const instrumentation: ChildProcess = spawn('adb', ['-s', deviceId, 'shell', 'am', 'instrument', '-w', `${bridgePackage}/.TreeInstrumentation`], { stdio: ['ignore', 'pipe', 'pipe'] })
-  let bridgeStarted = false
-  let forwarded = false
-  try {
-    adb('forward', `tcp:${hostPort}`, `tcp:${devicePort}`)
-    forwarded = true
-    await readyBridge()
-    bridgeStarted = true
-    adb('shell', 'am', 'force-stop', fixturePackage)
-    adb('shell', 'am', 'start', '-n', `${fixturePackage}/.MainActivity`, '--ez', 'silentTimer', 'true')
-    const initialDeadline = Date.now() + 5000
-    let initialTimer = false
-    while (Date.now() < initialDeadline) {
-      initialTimer = nodes((await bridgeRead()).xml).some((node) => node['@_content-desc'] === 'silent timer 0:00')
-      if (initialTimer) break
-      await sleep(50)
-    }
-    if (!initialTimer) throw new Error('Bridge did not observe the initial silent timer')
-    await sleep(2300)
-    const updatedTimer = nodes((await bridgeRead()).xml).some((node) => node['@_content-desc'] === 'silent timer 0:01')
-    if (!updatedTimer) throw new Error('Bridge reused a cached timer node after a visible update without an accessibility event')
-    adb('shell', 'am', 'force-stop', fixturePackage)
-    adb('shell', 'pm', 'clear', fixturePackage)
-    adb('shell', 'am', 'start', '-n', `${fixturePackage}/.MainActivity`, '--es', 'networkBaseUrl', `http://10.0.2.2:${address.port}`, '--es', 'networkRunId', runId)
-    await Promise.race([requestPromise, sleep(10000).then(() => { throw new Error('Fixture request timed out') })])
-    const loadingDeadline = Date.now() + 10000
-    let loadingOnly = false
-    while (Date.now() < loadingDeadline) {
-      const tree = nodes((await bridgeRead()).xml)
-      loadingOnly = tree.some((node) => node['@_content-desc'] === 'loading') && !tree.some((node) => node['@_content-desc'] === 'ready' || node['@_content-desc'] === 'value')
-      if (loadingOnly) break
-      await sleep(50)
-    }
-    if (!loadingOnly) throw new Error('Bridge did not observe loading-only state')
-    releaseResponse()
-    while (!responseSentNs) await sleep(10)
-    const readyDeadline = Date.now() + 10000
-    let readyRead: Awaited<ReturnType<typeof bridgeRead>> | undefined
-    while (Date.now() < readyDeadline) {
-      const read = await bridgeRead()
-      const tree = nodes(read.xml)
-      if (tree.some((node) => node['@_content-desc'] === 'ready') && tree.some((node) => node['@_content-desc'] === 'value' && node['@_text'] === `value-${runId}`)) {
-        readyRead = read
-        break
-      }
-      await sleep(50)
-    }
-    if (!readyRead || readyRead.started_ns <= responseSentNs) throw new Error('Bridge ready/value assertion was not based on a post-response read')
-    const bridgeSamples = []
-    for (let index = 0; index < 10; index++) bridgeSamples.push(await bridgeRead())
-    await stopBridge()
-    bridgeStarted = false
-    if (instrumentation.exitCode === null) await new Promise<void>((resolve) => instrumentation.once('close', () => resolve()))
-    adb('forward', '--remove', `tcp:${hostPort}`)
-    forwarded = false
-    const legacySamples: Array<{ xml: string; elapsed_ms: number }> = []
-    for (let index = 0; index < 10; index++) {
-      const started = process.hrtime.bigint()
-      // Android may still be releasing the instrumentation accessibility connection.
-      for (let retry = 0; ; retry++) {
-        try { adb('shell', 'uiautomator', 'dump', '/sdcard/ui.xml'); break }
-        catch (error) {
-          if (retry === 2) throw error
-          await sleep(500)
-        }
-      }
-      const xml = adb('shell', 'cat', '/sdcard/ui.xml')
-      legacySamples.push({ xml, elapsed_ms: elapsedMs(started) })
-    }
-    const bridgeNodes = nodes(bridgeSamples[0].xml)
-    const legacyNodes = nodes(legacySamples[0].xml)
-    const countIdentifiers = (items: Array<Record<string, string>>) => items.filter((node) => node['@_resource-id'] || node['@_content-desc']).length
-    const report = {
-      platform: 'android', device_id: '[redacted]', fixture: 'latency-journey-app',
-      network_freshness_passed: true,
-      silent_timer_freshness_passed: true,
-      bridge: { samples: summarize(bridgeSamples.map((sample) => sample.elapsed_ms)), node_count: bridgeNodes.length, identified_nodes: countIdentifiers(bridgeNodes) },
-      legacy: { samples: summarize(legacySamples.map((sample) => sample.elapsed_ms)), node_count: legacyNodes.length, identified_nodes: countIdentifiers(legacyNodes) }
-    }
-    const output = path.resolve('docs/benchmarks/ui-tree-performance/bridge-probe.json')
-    mkdirSync(path.dirname(output), { recursive: true })
-    writeFileSync(output, JSON.stringify(report, null, 2))
-    console.log(JSON.stringify(report))
-  } finally {
-    if (bridgeStarted) await stopBridge().catch(() => instrumentation.kill())
-    if (forwarded) { try { adb('forward', '--remove', `tcp:${hostPort}`) } catch { /* Best-effort cleanup. */ } }
-    if (!instrumentation.killed && instrumentation.exitCode === null) instrumentation.kill()
-    server.closeAllConnections()
-    await new Promise<void>((resolve) => server.close(() => resolve()))
-  }
-}
-
-main().catch((error) => { console.error(error); process.exitCode = 1 })

package/test/fixtures/ui-tree-bridge/AndroidManifest.xml

@@ -1,6 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="dev.mobiledebugmcp.treebridge">
-  <uses-sdk android:minSdkVersion="26" android:targetSdkVersion="36" />
-  <uses-permission android:name="android.permission.INTERNET" />
-  <application android:label="UI Tree Bridge" />
-  <instrumentation android:name=".TreeInstrumentation" android:targetPackage="dev.mobiledebugmcp.treebridge" android:exported="true" />
-</manifest>

package/test/fixtures/ui-tree-bridge/build.ts

@@ -1,34 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import { existsSync, mkdirSync } from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-export function buildBridge() {
-  const root = path.dirname(fileURLToPath(import.meta.url))
-  const out = path.join(root, 'build')
-  const sdk = process.env.ANDROID_SDK_ROOT || process.env.ANDROID_HOME ||
-    (process.platform === 'darwin' && process.env.HOME ? path.join(process.env.HOME, 'Library/Android/sdk') : '')
-  if (!sdk) throw new Error('Android SDK not found: set ANDROID_SDK_ROOT or ANDROID_HOME')
-  const buildTools = path.join(sdk, 'build-tools', '36.0.0')
-  const androidJar = path.join(sdk, 'platforms', 'android-36', 'android.jar')
-  if (!existsSync(androidJar) || !existsSync(buildTools)) {
-    throw new Error(`Android SDK 36 platform and build-tools 36.0.0 are required under ${sdk}`)
-  }
-  const java = process.env.JAVA_HOME
-  const tool = (name: string) => java ? path.join(java, 'bin', name) : name
-  const run = (cmd: string, args: string[]) => execFileSync(cmd, args, { cwd: out, stdio: 'pipe' })
-  mkdirSync(path.join(out, 'classes'), { recursive: true })
-  run(tool('javac'), ['--release', '8', '-classpath', androidJar, '-d', 'classes', path.join(root, 'src/TreeInstrumentation.java')])
-  run(tool('jar'), ['cf', 'classes.jar', '-C', 'classes', '.'])
-  run(path.join(buildTools, 'd8'), ['--lib', androidJar, '--output', out, 'classes.jar'])
-  run(path.join(buildTools, 'aapt2'), ['link', '-I', androidJar, '--manifest', path.join(root, 'AndroidManifest.xml'), '-o', 'unsigned.apk'])
-  run('zip', ['-q', 'unsigned.apk', 'classes.dex'])
-  run(path.join(buildTools, 'zipalign'), ['-f', '4', 'unsigned.apk', 'aligned.apk'])
-  try { run(tool('keytool'), ['-genkeypair', '-keystore', 'fixture.jks', '-storepass', 'android', '-keypass', 'android', '-alias', 'fixture', '-dname', 'CN=UI Tree Bridge', '-keyalg', 'RSA', '-validity', '3650']) } catch { /* Existing local fixture key. */ }
-  run(path.join(buildTools, 'apksigner'), ['sign', '--ks', 'fixture.jks', '--ks-pass', 'pass:android', '--out', 'bridge.apk', 'aligned.apk'])
-  return path.join(out, 'bridge.apk')
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  console.log(buildBridge())
-}

package/test/fixtures/ui-tree-bridge/src/TreeInstrumentation.java

@@ -1,126 +0,0 @@
-package dev.mobiledebugmcp.treebridge;
-
-import android.app.Instrumentation;
-import android.app.UiAutomation;
-import android.graphics.Rect;
-import android.os.Bundle;
-import android.os.Build;
-import android.util.Xml;
-import android.util.Log;
-import android.view.accessibility.AccessibilityNodeInfo;
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.StringWriter;
-import java.net.InetAddress;
-import java.net.ServerSocket;
-import java.net.Socket;
-import org.xmlpull.v1.XmlSerializer;
-
-/** Benchmark-only bridge: one live accessibility acquisition per TREE request. */
-public final class TreeInstrumentation extends Instrumentation {
-  private static final int PORT = 39019;
-
-  @Override public void onCreate(Bundle arguments) {
-    super.onCreate(arguments);
-    start();
-  }
-
-  @Override public void onStart() {
-    try (ServerSocket server = new ServerSocket(PORT, 1, InetAddress.getByName("127.0.0.1"))) {
-      UiAutomation automation = getUiAutomation(UiAutomation.FLAG_DONT_SUPPRESS_ACCESSIBILITY_SERVICES);
-      while (true) {
-        try (Socket socket = server.accept()) {
-          socket.setSoTimeout(10000);
-          BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
-          OutputStreamWriter output = new OutputStreamWriter(socket.getOutputStream(), "UTF-8");
-          String command = input.readLine();
-          if ("STOP".equals(command)) {
-            output.write("OK\n");
-            output.flush();
-            break;
-          }
-          if ("PING".equals(command)) {
-            output.write("OK\n");
-            output.flush();
-            continue;
-          }
-          if (!"TREE".equals(command)) {
-            output.write("ERROR invalid_command\n");
-          } else {
-            if (Build.VERSION.SDK_INT < 34) {
-              output.write("ERROR cache_clear_unavailable\n");
-            } else if (!automation.clearCache()) {
-              output.write("ERROR cache_clear_failed\n");
-            } else {
-              AccessibilityNodeInfo root = automation.getRootInActiveWindow();
-              if (root == null) {
-                output.write("ERROR null_root\n");
-              } else {
-                output.write("OK\n");
-                output.write(serialize(root));
-                root.recycle();
-              }
-            }
-          }
-          output.flush();
-        } catch (Exception error) {
-          // A failed client request cannot make a later acquisition reuse its tree.
-          Log.e("TreeBridge", "request failed", error);
-        }
-      }
-    } catch (Exception error) {
-      // The host-side probe detects failure to start or connect.
-      Log.e("TreeBridge", "bridge failed", error);
-    }
-    finish(0, new Bundle());
-  }
-
-  private static String serialize(AccessibilityNodeInfo root) throws Exception {
-    StringWriter writer = new StringWriter();
-    XmlSerializer xml = Xml.newSerializer();
-    xml.setOutput(writer);
-    xml.startDocument("UTF-8", true);
-    xml.startTag("", "hierarchy");
-    writeNode(xml, root, 0);
-    xml.endTag("", "hierarchy");
-    xml.endDocument();
-    return writer.toString();
-  }
-
-  private static void writeNode(XmlSerializer xml, AccessibilityNodeInfo node, int index) throws Exception {
-    Rect bounds = new Rect();
-    node.getBoundsInScreen(bounds);
-    xml.startTag("", "node");
-    xml.attribute("", "index", Integer.toString(index));
-    xml.attribute("", "class", value(node.getClassName()));
-    xml.attribute("", "package", value(node.getPackageName()));
-    xml.attribute("", "text", value(node.getText()));
-    xml.attribute("", "content-desc", value(node.getContentDescription()));
-    xml.attribute("", "resource-id", value(node.getViewIdResourceName()));
-    xml.attribute("", "checkable", Boolean.toString(node.isCheckable()));
-    xml.attribute("", "checked", Boolean.toString(node.isChecked()));
-    xml.attribute("", "clickable", Boolean.toString(node.isClickable()));
-    xml.attribute("", "enabled", Boolean.toString(node.isEnabled()));
-    xml.attribute("", "focusable", Boolean.toString(node.isFocusable()));
-    xml.attribute("", "focused", Boolean.toString(node.isFocused()));
-    xml.attribute("", "scrollable", Boolean.toString(node.isScrollable()));
-    xml.attribute("", "long-clickable", Boolean.toString(node.isLongClickable()));
-    xml.attribute("", "password", Boolean.toString(node.isPassword()));
-    xml.attribute("", "selected", Boolean.toString(node.isSelected()));
-    xml.attribute("", "visible-to-user", Boolean.toString(node.isVisibleToUser()));
-    xml.attribute("", "bounds", bounds.toShortString());
-    for (int childIndex = 0; childIndex < node.getChildCount(); childIndex++) {
-      AccessibilityNodeInfo child = node.getChild(childIndex);
-      if (child != null && child.isVisibleToUser()) {
-        writeNode(xml, child, childIndex);
-      }
-      if (child != null) child.recycle();
-    }
-    xml.endTag("", "node");
-  }
-
-  private static String value(CharSequence input) {
-    return input == null ? "" : input.toString();
-  }
-}

package/test/unit/observe/android_tree_bridge_cleanup.test.ts

@@ -1,95 +0,0 @@
-import assert from 'node:assert/strict'
-import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { createServer } from 'node:net'
-import type { Socket } from 'node:net'
-import { tmpdir } from 'node:os'
-import path from 'node:path'
-import { readAndroidTreeFromBridge } from '../../../src/observe/android-tree-bridge.js'
-
-async function run() {
-  const directory = mkdtempSync(path.join(tmpdir(), 'mcp-tree-bridge-'))
-  const adbPath = path.join(directory, 'adb')
-  const apkPath = path.join(directory, 'bridge.apk')
-  const launchesPath = path.join(directory, 'launches')
-  const getpropsPath = path.join(directory, 'getprops')
-  const previous = new Map(['ADB_PATH', 'MOBILE_DEBUG_MCP_ANDROID_TREE_BRIDGE_APK', 'MCP_FAKE_BRIDGE_PORT', 'MCP_FAKE_BRIDGE_LAUNCHES', 'MCP_FAKE_BRIDGE_GETPROPS', 'MCP_FAKE_FORCE_STOP_FAIL', 'MCP_FAKE_SDK'].map((key) => [key, process.env[key]]))
-  let invalidTree = false
-  const sockets = new Set<Socket>()
-  const server = createServer((socket) => {
-    sockets.add(socket)
-    socket.once('close', () => sockets.delete(socket))
-    socket.once('data', (chunk) => {
-      const command = chunk.toString().trim()
-      socket.end(command === 'TREE'
-        ? invalidTree ? 'ERROR null_root\n' : 'OK\n<hierarchy><node class="android.view.View" /></hierarchy>'
-        : 'OK\n')
-    })
-  })
-  writeFileSync(apkPath, '')
-  writeFileSync(launchesPath, '')
-  writeFileSync(getpropsPath, '')
-  writeFileSync(adbPath, `#!/usr/bin/env node
-const fs = require('node:fs')
-const args = process.argv.slice(2).join(' ')
-if (args.includes('am instrument')) {
-  fs.appendFileSync(process.env.MCP_FAKE_BRIDGE_LAUNCHES, 'launch\\n')
-  setInterval(() => {}, 1000)
-} else if (args.includes('am force-stop') && process.env.MCP_FAKE_FORCE_STOP_FAIL === '1') {
-  process.exit(1)
-} else if (args.includes('forward tcp:0')) {
-  console.log(process.env.MCP_FAKE_BRIDGE_PORT)
-} else if (args.includes('getprop ro.build.version.sdk')) {
-  fs.appendFileSync(process.env.MCP_FAKE_BRIDGE_GETPROPS, 'getprop\\n')
-  console.log(process.env.MCP_FAKE_SDK || '36')
-}
-`)
-  chmodSync(adbPath, 0o755)
-  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
-  const address = server.address()
-  if (!address || typeof address === 'string') throw new Error('No test port')
-  process.env.ADB_PATH = adbPath
-  process.env.MOBILE_DEBUG_MCP_ANDROID_TREE_BRIDGE_APK = apkPath
-  process.env.MCP_FAKE_BRIDGE_PORT = String(address.port)
-  process.env.MCP_FAKE_BRIDGE_LAUNCHES = launchesPath
-  process.env.MCP_FAKE_BRIDGE_GETPROPS = getpropsPath
-  try {
-    assert.match(await readAndroidTreeFromBridge('test-device') ?? '', /<hierarchy>/)
-    invalidTree = true
-    process.env.MCP_FAKE_FORCE_STOP_FAIL = '1'
-    await assert.rejects(() => readAndroidTreeFromBridge('test-device'), /BRIDGE_CLEANUP_UNCONFIRMED/)
-    await assert.rejects(() => readAndroidTreeFromBridge('test-device'), /BRIDGE_CLEANUP_UNCONFIRMED/)
-    assert.equal(readFileSync(launchesPath, 'utf8').trim().split('\n').length, 1, 'failed cleanup must block a second launch')
-    invalidTree = false
-    delete process.env.MCP_FAKE_FORCE_STOP_FAIL
-    assert.match(await readAndroidTreeFromBridge('test-device') ?? '', /<hierarchy>/, 'successful cleanup allows relaunch')
-    for (let attempt = 0; attempt < 20 && readFileSync(launchesPath, 'utf8').trim().split('\n').length < 2; attempt++) {
-      await new Promise((resolve) => setTimeout(resolve, 50))
-    }
-    assert.equal(readFileSync(launchesPath, 'utf8').trim().split('\n').length, 2)
-    invalidTree = true
-    assert.equal(await readAndroidTreeFromBridge('test-device'), null, 'clean shutdown permits legacy fallback')
-    process.env.MCP_FAKE_SDK = '33'
-    assert.equal(await readAndroidTreeFromBridge('old-device'), null, 'older Android versions use the legacy reader')
-    assert.equal(await readAndroidTreeFromBridge('old-device'), null)
-    assert.equal(readFileSync(getpropsPath, 'utf8').trim().split('\n').length, 3, 'unsupported devices recheck SDK support')
-    process.env.MCP_FAKE_SDK = '36'
-    invalidTree = false
-    assert.match(await readAndroidTreeFromBridge('old-device') ?? '', /<hierarchy>/, 'a newly supported device can start the bridge')
-    for (let attempt = 0; attempt < 20 && readFileSync(launchesPath, 'utf8').trim().split('\n').length < 3; attempt++) {
-      await new Promise((resolve) => setTimeout(resolve, 50))
-    }
-    assert.equal(readFileSync(launchesPath, 'utf8').trim().split('\n').length, 3)
-    invalidTree = true
-    assert.equal(await readAndroidTreeFromBridge('old-device'), null, 'the new bridge shuts down before fallback')
-  } finally {
-    for (const [key, value] of previous) {
-      if (value === undefined) delete process.env[key]
-      else process.env[key] = value
-    }
-    for (const socket of sockets) socket.destroy()
-    await new Promise<void>((resolve) => server.close(() => resolve()))
-    rmSync(directory, { recursive: true, force: true })
-  }
-}
-
-run().catch((error) => { console.error(error); process.exitCode = 1 })