mobile-debug-mcp 0.7.0 → 0.9.0

package/test/unit/install.test.ts

@@ -0,0 +1,82 @@
+import assert from 'assert'
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+import { createRequire } from 'module'
+
+// This test mocks child_process.spawn and simulates a Gradle build producing an APK
+// and an adb install. It does not patch AndroidInteract.installApp itself so the
+// internal build-and-install logic is exercised.
+
+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 }
+}
+
+async function makeTempDirWith(name: string) {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-test-'))
+  await fs.writeFile(path.join(dir, name), '')
+  return dir
+}
+
+export async function run() {
+  // Create a fake adb executable in a temporary bin dir and prepend to PATH so
+  // execAdb's spawn('adb', ...) will find it. This avoids requiring a real adb
+  // 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)
+`
+  await fs.writeFile(adbPath, adbScript, { mode: 0o755 })
+  const origPath = process.env.PATH || ''
+  process.env.PATH = `${binDir}:${origPath}`
+
+  // Import the module under test after PATH is adjusted
+  const { AndroidInteract } = await import('../../src/android/interact.js')
+
+  try {
+    // Test: install with .apk file should call adb install
+    const { dir: d1, file: apk } = await makeTempFile('.apk')
+    const ai = new AndroidInteract()
+    const res1 = await ai.installApp(apk)
+    console.log('res1', res1)
+    assert.ok(res1.installed === true, 'APK install should succeed')
+
+    // 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)
+`
+    await fs.writeFile(gradlewPath, gradlewScript, { mode: 0o755 })
+
+    const res2 = await ai.installApp(dirGradle)
+    console.log('res2', res2)
+    assert.ok(res2.installed === true, 'Project dir (gradle) install should succeed')
+
+    // cleanup
+    await fs.rm(d1, { recursive: true, force: true }).catch(() => {})
+    await fs.rm(dirGradle, { recursive: true, force: true }).catch(() => {})
+
+    // restore PATH
+    process.env.PATH = origPath
+
+    console.log('install tests passed')
+  } finally {
+    // ensure PATH restored even on failure
+    process.env.PATH = origPath
+  }
+}
+
+run().catch((e) => { console.error(e); process.exit(1) })

package/test/unit/logparse.test.ts

@@ -0,0 +1,41 @@
+import { parseLogLine } from '../../src/android/utils.js'
+
+function assert(cond: boolean, msg?: string) { if (!cond) throw new Error(msg || 'Assertion failed') }
+
+function run() {
+  const samples = [
+    // Standard format
+    {
+      line: '03-13 15:08:25.257  2468  2578 E FromGoneTransitionInteractor: Ignoring startTransition: ...',
+      expect: { level: 'E', tag: 'FromGoneTransitionInteractor', crash: false }
+    },
+    // Full date format
+    {
+      line: '2026-03-13 15:08:25.257  2468  2578 E Something: Boom happened',
+      expect: { level: 'E', tag: 'Something', crash: false }
+    },
+    // Simple priority/tag
+    {
+      line: 'W/MyTag: Some warning here',
+      expect: { level: 'W', tag: 'MyTag', crash: false }
+    },
+    // Crash message
+    {
+      line: '03-13 15:09:01.123  9999  9999 E AndroidRuntime: FATAL EXCEPTION: main\njava.lang.NullPointerException: at ...',
+      expect: { level: 'E', tag: 'AndroidRuntime', crash: true, exceptionContains: 'NullPointerException' }
+    }
+  ]
+
+  for (const s of samples) {
+    const res = parseLogLine(s.line)
+    console.log('Parsed:', res)
+    assert(res.level === s.expect.level, `Expected level ${s.expect.level} got ${res.level}`)
+    assert(res.tag === s.expect.tag, `Expected tag ${s.expect.tag} got ${res.tag}`)
+    if (s.expect.crash) assert(res.crash === true, 'Expected crash true')
+    if (s.expect.exceptionContains) assert(res.exception && res.exception.indexOf(s.expect.exceptionContains) !== -1, 'Expected exception to contain ' + s.expect.exceptionContains)
+  }
+
+  console.log('Log parse tests passed')
+}
+
+run()

package/test/unit/logstream.test.ts

@@ -0,0 +1,46 @@
+import { promises as fs } from 'fs'
+import os from 'os'
+import path from 'path'
+import { readLogStreamLines, _setActiveLogStream, _clearActiveLogStream } from '../../src/android/utils.js'
+
+async function run() {
+  const tmp = os.tmpdir()
+  const file = path.join(tmp, `test-mobile-debug-log-${Date.now()}.ndjson`)
+
+  // Prepare NDJSON with one crash entry and one info entry
+  const crashEntry = { timestamp: '2026-03-13T14:00:00.000Z', level: 'E', tag: 'AndroidRuntime', message: 'FATAL EXCEPTION: main\njava.lang.NullPointerException' }
+  const infoEntry = { timestamp: '2026-03-13T14:01:00.000Z', level: 'I', tag: 'MyTag', message: 'Info message' }
+
+  await fs.writeFile(file, JSON.stringify(crashEntry) + '\n' + JSON.stringify(infoEntry) + '\n')
+
+  const sessionId = 'unit-test-logstream'
+  _setActiveLogStream(sessionId, file)
+
+  try {
+    // Read all
+    const { entries, crash_summary } = await readLogStreamLines(sessionId, 10)
+    if (!Array.isArray(entries) || entries.length !== 2) throw new Error('Expected 2 entries')
+    if (!crash_summary || crash_summary.crash_detected !== true) throw new Error('Expected crash_detected true')
+    if (!crash_summary.exception || !/NullPointerException/.test(crash_summary.exception)) throw new Error('Expected NullPointerException detected')
+
+    console.log('Test 1 PASS: basic parsing & crash detection')
+
+    // Test since filter (after first entry)
+    const since = new Date('2026-03-13T14:00:30.000Z').toISOString()
+    const r2 = await readLogStreamLines(sessionId, 10, since)
+    if (r2.entries.length !== 1) throw new Error('Expected 1 entry after since filter')
+    console.log('Test 2 PASS: since filter')
+
+    // Test limit
+    const r3 = await readLogStreamLines(sessionId, 1)
+    if (r3.entries.length !== 1) throw new Error('Expected 1 entry with limit=1')
+    console.log('Test 3 PASS: limit works')
+
+    console.log('ALL logstream tests passed')
+  } finally {
+    _clearActiveLogStream(sessionId)
+    await fs.unlink(file).catch(()=>{})
+  }
+}
+
+run().catch(err => { console.error('Logstream tests failed:', err); process.exit(1) })

package/test/unit/wait_for_element_mock.ts

@@ -0,0 +1,104 @@
+import { AndroidInteract } from "../../src/android/interact.js";
+import { AndroidObserve } from "../../src/android/observe.js";
+
+const originalGetUITree = (AndroidObserve as any).prototype.getUITree;
+
+async function runTests() {
+  console.log("Starting tests for wait_for_element...");
+  const interact = new AndroidInteract();
+
+  console.log("\nTest 1: Element found immediately");
+  (AndroidObserve as any).prototype.getUITree = async () => ({
+    device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
+    screen: "",
+    resolution: { width: 1080, height: 1920 },
+    elements: [{
+      text: "Target",
+      type: "Button",
+      contentDescription: null,
+      clickable: true,
+      enabled: true,
+      visible: true,
+      bounds: [0, 0, 100, 100],
+      resourceId: null
+    }]
+  });
+
+  const start1 = Date.now();
+  const result1 = await interact.waitForElement("Target", 1000);
+  const elapsed1 = Date.now() - start1;
+  console.log("Result:", result1.found === true ? "PASS" : "FAIL");
+  console.log("Element:", result1.element ? "FOUND" : "MISSING");
+  console.log("Elapsed:", elapsed1, "ms");
+
+  console.log("\nTest 2: Element not found (timeout)");
+  (AndroidObserve as any).prototype.getUITree = async () => ({
+    device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
+    screen: "",
+    resolution: { width: 1080, height: 1920 },
+    elements: []
+  });
+
+  const start2 = Date.now();
+  const result2 = await interact.waitForElement("Target", 1200);
+  const elapsed2 = Date.now() - start2;
+  console.log("Result:", result2.found === false ? "PASS" : "FAIL");
+  console.log("Elapsed time (should be >= 1200ms):", elapsed2, elapsed2 >= 1200 ? "PASS" : "FAIL");
+
+  console.log("\nTest 3: Element found after polling");
+  let calls = 0;
+  (AndroidObserve as any).prototype.getUITree = async () => {
+    calls++;
+    if (calls < 3) {
+      return {
+        device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
+        screen: "",
+        resolution: { width: 1080, height: 1920 },
+        elements: []
+      };
+    }
+    return {
+      device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
+      screen: "",
+      resolution: { width: 1080, height: 1920 },
+      elements: [{
+        text: "Target",
+        type: "Button",
+        contentDescription: null,
+        clickable: true,
+        enabled: true,
+        visible: true,
+        bounds: [0, 0, 100, 100],
+        resourceId: null
+      }]
+    };
+  };
+
+  const start3 = Date.now();
+  const result3 = await interact.waitForElement("Target", 2000);
+  const elapsed3 = Date.now() - start3;
+  console.log("Result:", result3.found === true ? "PASS" : "FAIL");
+  console.log("Calls:", calls, calls === 3 ? "PASS" : "FAIL");
+  console.log("Elapsed time (should be >= 1000ms):", elapsed3, elapsed3 >= 1000 ? "PASS" : "FAIL");
+
+  console.log("\nTest 4: Error handling (fast failure)");
+  (AndroidObserve as any).prototype.getUITree = async () => ({
+    device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
+    screen: "",
+    resolution: { width: 0, height: 0 },
+    elements: [],
+    error: "ADB Connection Failed"
+  });
+
+  const start4 = Date.now();
+  const result4 = await interact.waitForElement("Target", 5000);
+  const elapsed4 = Date.now() - start4;
+  console.log("Result:", result4.found === false && result4.error === "ADB Connection Failed" ? "PASS" : "FAIL");
+  console.log("Error Message:", result4.error);
+  console.log("Elapsed time (should be < 500ms):", elapsed4, elapsed4 < 500 ? "PASS" : "FAIL");
+
+  // Restore
+  (AndroidObserve as any).prototype.getUITree = originalGetUITree;
+}
+
+runTests().catch(console.error);

package/tsconfig.json

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

package/smoke-test.js

@@ -1,102 +0,0 @@
-import { startAndroidApp, terminateAndroidApp, captureAndroidScreen, getAndroidLogs } from "./src/android.js";
-import { startIOSApp, terminateIOSApp, captureIOSScreenshot, getIOSLogs } from "./src/ios.js";
-import fs from "fs/promises";
-async function main() {
-    const args = process.argv.slice(2);
-    const platform = args[0]; // Cast to string first
-    const appId = args[1];
-    if ((platform !== "android" && platform !== "ios") || !appId) {
-        console.error("Usage: npx tsx smoke-test.ts <android|ios> <appId>");
-        process.exit(1);
-    }
-    console.log(`\n🚀 Starting smoke test for ${platform} app: ${appId}`);
-    try {
-        // 1. Start App
-        console.log(`[1/4] Starting app...`);
-        let startResult;
-        let launchTimeMs;
-        if (platform === "android") {
-            const result = await startAndroidApp(appId);
-            startResult = result.appStarted;
-            launchTimeMs = result.launchTimeMs;
-        }
-        else {
-            const result = await startIOSApp(appId);
-            startResult = result.appStarted;
-            launchTimeMs = result.launchTimeMs;
-        }
-        if (startResult) {
-            console.log(`✅ App started successfully (Launch time: ${launchTimeMs}ms)`);
-        }
-        else {
-            throw new Error("Failed to start app");
-        }
-        // Wait for app to settle
-        console.log(`⏳ Waiting 3s for app to load...`);
-        await new Promise(r => setTimeout(r, 3000));
-        // 2. Capture Screenshot
-        console.log(`[2/4] Capturing screenshot...`);
-        let screenshotBase64;
-        let resolution;
-        if (platform === "android") {
-            const result = await captureAndroidScreen(appId);
-            screenshotBase64 = result.screenshot;
-            resolution = result.resolution;
-        }
-        else {
-            const result = await captureIOSScreenshot();
-            screenshotBase64 = result.screenshot;
-            resolution = result.resolution;
-        }
-        if (screenshotBase64) {
-            const fileName = `smoke-test-${platform}.png`;
-            await fs.writeFile(fileName, Buffer.from(screenshotBase64, 'base64'));
-            console.log(`✅ Screenshot saved to ./${fileName} (${resolution.width}x${resolution.height})`);
-        }
-        else {
-            throw new Error("Failed to capture screenshot");
-        }
-        // 3. Get Logs
-        console.log(`[3/4] Fetching logs...`);
-        let logsCount = 0;
-        let logs = [];
-        if (platform === "android") {
-            const result = await getAndroidLogs(appId, 50);
-            logsCount = result.logCount;
-            logs = result.logs;
-        }
-        else {
-            const result = await getIOSLogs();
-            logsCount = result.logCount;
-            logs = result.logs;
-        }
-        console.log(`✅ Retrieved ${logsCount} log lines`);
-        // Print last log line as sample
-        if (logs.length > 0) {
-            console.log(`   Sample: "${logs[logs.length - 1].substring(0, 80)}..."`);
-        }
-        // 4. Terminate App
-        console.log(`[4/4] Terminating app...`);
-        let termResult;
-        if (platform === "android") {
-            const result = await terminateAndroidApp(appId);
-            termResult = result.appTerminated;
-        }
-        else {
-            const result = await terminateIOSApp(appId);
-            termResult = result.appTerminated;
-        }
-        if (termResult) {
-            console.log(`✅ App terminated successfully`);
-        }
-        else {
-            throw new Error("Failed to terminate app");
-        }
-        console.log(`\n✨ Smoke test COMPLETED SUCCESSFULLY! ✨\n`);
-    }
-    catch (error) {
-        console.error(`\n❌ Smoke test FAILED:`, error);
-        process.exit(1);
-    }
-}
-main();

package/test/run-real-test.js

@@ -1,24 +0,0 @@
-// This script wraps the real test execution for ease of use
-// It sets ADB_PATH and invokes the test file
-import { spawn } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const ADB_PATH = process.env.ADB_PATH || process.env.ADB || 'adb';
-const TEST_FILE = path.join(__dirname, 'wait_for_element_real.js');
-
-// Merge ADB_PATH into the child environment if provided
-const childEnv = { ...process.env, ADB_PATH };
-
-// Use NODE to execute the JS test by default, or respect RUNNER env if set (e.g., 'npx tsx')
-const runner = process.env.RUNNER || 'node';
-const runnerArgs = [TEST_FILE];
-
-const child = spawn(runner, runnerArgs, {
-    env: childEnv,
-    stdio: 'inherit'
-});
-child.on('exit', (code) => {
-    process.exit(code || 0);
-});

package/test/wait_for_element_mock.js

@@ -1,113 +0,0 @@
-import { AndroidInteract } from "../src/android/interact.js";
-import { AndroidObserve } from "../src/android/observe.js";
-// Mock the observe method
-// We need to override the prototype method directly
-// Since we are using ES modules, we need to handle the import correctly or just override the instance method if possible.
-// But getUITree is an instance method on AndroidObserve, which AndroidInteract instantiates internally.
-// We can override the prototype of AndroidObserve to affect all instances.
-const originalGetUITree = AndroidObserve.prototype.getUITree;
-async function runTests() {
-    console.log("Starting tests for wait_for_element...");
-    const interact = new AndroidInteract();
-    // ---------------------------------------------------------
-    // Test 1: Element found immediately
-    // ---------------------------------------------------------
-    console.log("\nTest 1: Element found immediately");
-    AndroidObserve.prototype.getUITree = async () => ({
-        device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
-        screen: "",
-        resolution: { width: 1080, height: 1920 },
-        elements: [{
-                text: "Target",
-                type: "Button",
-                contentDescription: null,
-                clickable: true,
-                enabled: true,
-                visible: true,
-                bounds: [0, 0, 100, 100],
-                resourceId: null
-            }]
-    });
-    const start1 = Date.now();
-    const result1 = await interact.waitForElement("Target", 1000);
-    const elapsed1 = Date.now() - start1;
-    console.log("Result:", result1.found === true ? "PASS" : "FAIL");
-    console.log("Element:", result1.element ? "FOUND" : "MISSING");
-    console.log("Elapsed:", elapsed1, "ms");
-    // ---------------------------------------------------------
-    // Test 2: Element not found (timeout)
-    // ---------------------------------------------------------
-    console.log("\nTest 2: Element not found (timeout)");
-    AndroidObserve.prototype.getUITree = async () => ({
-        device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
-        screen: "",
-        resolution: { width: 1080, height: 1920 },
-        elements: []
-    });
-    const start2 = Date.now();
-    // Use a short timeout for test speed, but long enough to sleep at least once
-    const result2 = await interact.waitForElement("Target", 1200);
-    const elapsed2 = Date.now() - start2;
-    console.log("Result:", result2.found === false ? "PASS" : "FAIL");
-    // Should wait at least 1200ms
-    console.log("Elapsed time (should be >= 1200ms):", elapsed2, elapsed2 >= 1200 ? "PASS" : "FAIL");
-    // ---------------------------------------------------------
-    // Test 3: Element found after polling
-    // ---------------------------------------------------------
-    console.log("\nTest 3: Element found after polling");
-    let calls = 0;
-    AndroidObserve.prototype.getUITree = async () => {
-        calls++;
-        if (calls < 3) {
-            return {
-                device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
-                screen: "",
-                resolution: { width: 1080, height: 1920 },
-                elements: []
-            };
-        }
-        return {
-            device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
-            screen: "",
-            resolution: { width: 1080, height: 1920 },
-            elements: [{
-                    text: "Target",
-                    type: "Button",
-                    contentDescription: null,
-                    clickable: true,
-                    enabled: true,
-                    visible: true,
-                    bounds: [0, 0, 100, 100],
-                    resourceId: null
-                }]
-        };
-    };
-    const start3 = Date.now();
-    const result3 = await interact.waitForElement("Target", 2000);
-    const elapsed3 = Date.now() - start3;
-    console.log("Result:", result3.found === true ? "PASS" : "FAIL");
-    console.log("Calls:", calls, calls === 3 ? "PASS" : "FAIL");
-    // Expected calls: 0ms (fail), 500ms (fail), 1000ms (success). Elapsed should be >= 1000ms.
-    console.log("Elapsed time (should be >= 1000ms):", elapsed3, elapsed3 >= 1000 ? "PASS" : "FAIL");
-    // ---------------------------------------------------------
-    // Test 4: Error handling (fast failure)
-    // ---------------------------------------------------------
-    console.log("\nTest 4: Error handling (fast failure)");
-    AndroidObserve.prototype.getUITree = async () => ({
-        device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true },
-        screen: "",
-        resolution: { width: 0, height: 0 },
-        elements: [],
-        error: "ADB Connection Failed"
-    });
-    const start4 = Date.now();
-    const result4 = await interact.waitForElement("Target", 5000);
-    const elapsed4 = Date.now() - start4;
-    console.log("Result:", result4.found === false && result4.error === "ADB Connection Failed" ? "PASS" : "FAIL");
-    console.log("Error Message:", result4.error);
-    // Should fail fast, not wait for timeout
-    console.log("Elapsed time (should be < 500ms):", elapsed4, elapsed4 < 500 ? "PASS" : "FAIL");
-    // Restore original
-    AndroidObserve.prototype.getUITree = originalGetUITree;
-}
-runTests().catch(console.error);

package/test/wait_for_element_real.js

@@ -1,67 +0,0 @@
-import { AndroidInteract } from "../src/android/interact.js";
-import { AndroidObserve } from "../src/android/observe.js";
-// Configure ADB path and target via env vars or CLI args.
-// Usage: node test/wait_for_element_real.js [deviceId] [appId]
-// Priority: CLI args > environment variables
-const args = process.argv.slice(2);
-const DEVICE_ID = args[0] || process.env.DEVICE_ID;
-const APP_ID = args[1] || process.env.APP_ID;
-
-// Do not hard-code ADB_PATH here. If the user supplied ADB_PATH in the environment, leave it as-is.
-// (process.env.ADB_PATH may be set externally before running this script.)
-
-if (!DEVICE_ID || !APP_ID) {
-  console.error("Usage: node test/wait_for_element_real.js <deviceId> <appId> or set DEVICE_ID and APP_ID env vars");
-  process.exit(1);
-}
-async function runRealTest() {
-    console.log(`Connecting to device ${DEVICE_ID}...`);
-    const interact = new AndroidInteract();
-    const observe = new AndroidObserve();
-    try {
-        // 1. Start App
-        console.log(`\nStarting app ${APP_ID}...`);
-        await interact.startApp(APP_ID, DEVICE_ID);
-        // Give it a moment to render
-        console.log("Waiting 3s for app to render...");
-        await new Promise(r => setTimeout(r, 3000));
-        // 2. Get UI Tree to find a valid text target
-        console.log("\nFetching UI Tree to find a target text...");
-        const tree = await observe.getUITree(DEVICE_ID);
-        if (tree.error) {
-            console.error("Failed to get UI Tree:", tree.error);
-            return;
-        }
-        // Find first visible element with text
-        const targetElement = tree.elements.find(e => e.text && e.text.length > 0 && e.visible);
-        if (!targetElement || !targetElement.text) {
-            console.warn("No visible text elements found on screen to test with.");
-            console.log("Elements found:", tree.elements.length);
-            return;
-        }
-        const targetText = targetElement.text;
-        console.log(`Found target element: "${targetText}"`);
-        // 3. Test waitForElement (Success Case)
-        console.log(`\nTest 1: Waiting for existing element "${targetText}" (should succeed)...`);
-        const start1 = Date.now();
-        const result1 = await interact.waitForElement(targetText, 5000, DEVICE_ID);
-        const elapsed1 = Date.now() - start1;
-        console.log(`Result: ${result1.found ? "PASS" : "FAIL"}`);
-        console.log(`Found Element: ${result1.element?.text}`);
-        console.log(`Time taken: ${elapsed1}ms`);
-        // 4. Test waitForElement (Timeout Case)
-        const missingText = "THIS_TEXT_SHOULD_NOT_EXIST_XYZ_123";
-        console.log(`\nTest 2: Waiting for missing element "${missingText}" (should timeout)...`);
-        const start2 = Date.now();
-        // Use short timeout 2s
-        const result2 = await interact.waitForElement(missingText, 2000, DEVICE_ID);
-        const elapsed2 = Date.now() - start2;
-        console.log(`Result: ${!result2.found ? "PASS" : "FAIL"}`);
-        console.log(`Found: ${result2.found}`);
-        console.log(`Time taken: ${elapsed2}ms (expected ~2000ms)`);
-    }
-    catch (error) {
-        console.error("Test failed with error:", error);
-    }
-}
-runRealTest();

package/test-ui-tree.js

@@ -1,68 +0,0 @@
-/**
- * Test script for verify UI Tree functionality.
- *
- * Usage:
- *   npx tsx test-ui-tree.ts [android|ios] [deviceId]
- *
- * Examples:
- *   npx tsx test-ui-tree.ts android
- *   npx tsx test-ui-tree.ts ios booted
- */
-import { AndroidObserve } from "./src/android/observe.js";
-import { iOSObserve } from "./src/ios/observe.js";
-async function main() {
-    const args = process.argv.slice(2);
-    const platform = (args[0] || 'android').toLowerCase();
-    const deviceId = args[1];
-    console.log(`Starting UI Tree Test for ${platform}...`);
-    if (deviceId)
-        console.log(`Targeting device: ${deviceId}`);
-    try {
-        let result;
-        if (platform === 'ios') {
-            const observer = new iOSObserve();
-            result = await observer.getUITree(deviceId || 'booted');
-        }
-        else {
-            const observer = new AndroidObserve();
-            result = await observer.getUITree(deviceId);
-        }
-        console.log("\nUI Tree Result Summary:");
-        console.log("-----------------------");
-        if (result.error) {
-            console.error("❌ Error:", result.error);
-            process.exit(1);
-        }
-        console.log(`Device: ${result.device.platform} (${result.device.model || 'Unknown Model'})`);
-        console.log(`Resolution: ${result.resolution.width}x${result.resolution.height}`);
-        console.log(`Elements Found: ${result.elements.length}`);
-        if (result.elements.length === 0) {
-            console.warn("⚠️ Warning: No elements found. Is the screen empty or locked?");
-        }
-        else {
-            // Print sample element to verify structure
-            const first = result.elements[0];
-            console.log("\nSample Element (First):");
-            console.log(JSON.stringify(first, null, 2));
-            // Check for new fields
-            if (first.center && first.depth !== undefined) {
-                console.log("\n✅ Verified 'center' and 'depth' fields exist.");
-            }
-            else {
-                console.error("\n❌ 'center' or 'depth' fields missing!");
-                process.exit(1);
-            }
-            // Check for filtering
-            const interactive = result.elements.filter(e => e.clickable).length;
-            const withText = result.elements.filter(e => e.text).length;
-            console.log(`\nStats:`);
-            console.log(`- Interactive elements: ${interactive}`);
-            console.log(`- Elements with text: ${withText}`);
-        }
-    }
-    catch (error) {
-        console.error("\n❌ Test Failed:", error);
-        process.exit(1);
-    }
-}
-main();