mobile-debug-mcp 0.21.0 → 0.21.2

package/test/interact/unit/{observe_until.test.ts → wait_for_ui.test.ts}

@@ -2,7 +2,7 @@ import { ToolsInteract } from '../../../src/interact/index.js'
 import * as Observe from '../../../src/observe/index.js'
 
 async function runTests() {
-  console.log('Starting observe_until unit tests...')
+  console.log('Starting wait_for_ui unit tests...')
 
   const origFind = (ToolsInteract as any).findElementHandler
   const origReadLog = (Observe as any).ToolsObserve.readLogStreamHandler
@@ -17,7 +17,7 @@ async function runTests() {
     ;(Observe as any).ToolsObserve.captureDebugSnapshotHandler = async ({ reason }: any) => ({ reason, fingerprint: 'snap-123', ui_tree: null, logs: [] })
     // make findElement always fail
     (ToolsInteract as any).findElementHandler = async () => ({ found: false })
-    const resTimeout = await ToolsInteract.observeUntilHandler({ type: 'ui', query: 'WillNeverExist', timeoutMs: 500, pollIntervalMs: 100, platform: 'android' })
+    const resTimeout = await ToolsInteract.waitForUIHandler({ type: 'ui', query: 'WillNeverExist', timeoutMs: 500, pollIntervalMs: 100, platform: 'android' })
     const okTimeout = resTimeout && !(resTimeout as any).success && (resTimeout as any).snapshot && (resTimeout as any).snapshot.fingerprint === 'snap-123' && (resTimeout as any).telemetry && (resTimeout as any).telemetry.pollCount > 0
     console.log('Timeout Snapshot Test:', okTimeout ? 'PASS' : 'FAIL', JSON.stringify((resTimeout as any).telemetry || {}, null, 2))
     ;(Observe as any).ToolsObserve.captureDebugSnapshotHandler = origCapture
@@ -31,7 +31,7 @@ async function runTests() {
       return { found: false }
     }
 
-    const resUi = await ToolsInteract.observeUntilHandler({ type: 'ui', query: 'Generate Session', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
+    const resUi = await ToolsInteract.waitForUIHandler({ type: 'ui', query: 'Generate Session', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
     const okUi = resUi && (resUi as any).success && (resUi as any).telemetry && (resUi as any).telemetry.pollCount > 0 && (resUi as any).telemetry.timeToMatch >= 0
     console.log('UI Test:', okUi ? 'PASS' : 'FAIL', JSON.stringify((resUi as any).telemetry || {}, null, 2))
 
@@ -44,21 +44,21 @@ async function runTests() {
       return { device: {}, logs: ['INFO start', 'ERROR Exception occurred', 'Server: Boom'] }
     }
 
-    const resLog = await ToolsInteract.observeUntilHandler({ type: 'log', query: 'Server', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
+    const resLog = await ToolsInteract.waitForUIHandler({ type: 'log', query: 'Server', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
     const okLog = resLog && (resLog as any).success && (resLog as any).telemetry && (resLog as any).telemetry.pollCount > 0 && (resLog as any).telemetry.matchSource === 'log-snapshot'
     console.log('Log Test:', okLog ? 'PASS' : 'FAIL', JSON.stringify((resLog as any).telemetry || {}, null, 2))
 
     // Screen condition: fingerprint changes after a few polls
     let seq = ['A', 'A', 'B']
     ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: seq.length ? seq.shift() : null })
-    const resScreen = await ToolsInteract.observeUntilHandler({ type: 'screen', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
+    const resScreen = await ToolsInteract.waitForUIHandler({ type: 'screen', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
     const okScreen = resScreen && (resScreen as any).success && (resScreen as any).telemetry && (resScreen as any).telemetry.matchSource === 'screen-fingerprint'
     console.log('Screen Test:', okScreen ? 'PASS' : 'FAIL', JSON.stringify((resScreen as any).telemetry || {}, null, 2))
 
     // Idle condition: stable fingerprints observed
     let idleSeq = ['X', 'X', 'X']
     ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: idleSeq.length ? idleSeq.shift() : 'X' })
-    const resIdle = await ToolsInteract.observeUntilHandler({ type: 'idle', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
+    const resIdle = await ToolsInteract.waitForUIHandler({ type: 'idle', timeoutMs: 3000, pollIntervalMs: 100, platform: 'android' })
     const okIdle = resIdle && (resIdle as any).success && (resIdle as any).telemetry && (resIdle as any).telemetry.matchSource === 'idle-stable'
     console.log('Idle Test:', okIdle ? 'PASS' : 'FAIL', JSON.stringify((resIdle as any).telemetry || {}, null, 2))
 

package/test/observe/device/wait_for_element_real.ts

@@ -1,80 +1,3 @@
-import { AndroidInteract } from "../../src/interact/index.js";
-import { AndroidObserve } from "../../src/observe/index.js";
-
-// Usage: npx tsx test/wait_for_element_real.ts <deviceId> <appId>
-const args = process.argv.slice(2);
-const DEVICE_ID = args[0] || process.env.DEVICE_ID;
-const APP_ID = args[1] || process.env.APP_ID;
-
-if (!DEVICE_ID || !APP_ID) {
-  console.error("Usage: npx tsx test/wait_for_element_real.ts <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 {
-    console.log(`\nStarting app ${APP_ID}...`);
-    await interact.startApp(APP_ID, DEVICE_ID);
-    console.log("Waiting 3s for app to render...");
-    await new Promise(r => setTimeout(r, 3000));
-
-    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;
-    }
-
-    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}"`);
-
-    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`);
-
-    const missingText = "THIS_TEXT_SHOULD_NOT_EXIST_XYZ_123";
-    console.log(`\nTest 2: Waiting for missing element "${missingText}" (should timeout)...`);
-    const start2 = Date.now();
-    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)`);
-
-    console.log(`\nTest 3: Found after polling`);
-    let calls = 0;
-    AndroidObserve.prototype.getUITree = async function() {
-      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 }] };
-    } as any;
-
-    const start3 = Date.now();
-    const result3 = await interact.waitForElement("Target", 2000, DEVICE_ID);
-    const elapsed3 = Date.now() - start3;
-    console.log(`Result: ${result3.found ? "PASS" : "FAIL"}`);
-    console.log(`Calls: ${calls} ${calls === 3 ? "PASS" : "FAIL"}`);
-    console.log(`Elapsed time (should be >= 1000ms): ${elapsed3} ${elapsed3 >= 1000 ? "PASS" : "FAIL"}`);
-
-  } catch {
-    console.error("Test failed with error:", error);
-  }
-}
-
-runRealTest();
+// wait_for_element device runner removed
+console.log('wait_for_element device test removed');
+process.exit(0);

package/test/observe/unit/wait_for_element_mock.ts

@@ -1,104 +1,2 @@
-import { AndroidInteract } from '../../../src/interact/index.js';
-import { AndroidObserve } from '../../../src/observe/index.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 < 1000ms):", elapsed4, elapsed4 < 1000 ? "PASS" : "FAIL");
-
-  // Restore
-  (AndroidObserve as any).prototype.getUITree = originalGetUITree;
-}
-
-runTests().catch(console.error);
+// wait_for_element tests removed — tool deprecated
+console.log('wait_for_element unit tests removed');

package/test/observe/unit/{observe_until_edge_cases.test.ts → wait_for_ui_edge_cases.test.ts}

@@ -2,7 +2,7 @@ import { ToolsInteract } from '../../../../src/interact/index.js'
 import * as Observe from '../../../../src/observe/index.js'
 
 async function run() {
-  console.log('Unit: observe_until edge cases')
+  console.log('Unit: wait_for_ui edge cases')
 
   const origFind = (ToolsInteract as any).findElementHandler
   const origFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
@@ -10,26 +10,26 @@ async function run() {
   try {
     // 1) Immediate absence should pass for match='absent'
     (ToolsInteract as any).findElementHandler = async () => ({ found: false })
-    const r1 = await (ToolsInteract as any).observeUntilHandler({ type: 'ui', query: 'Nothing', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 200, match: 'absent', platform: 'android' })
+    const r1 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Nothing', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 200, match: 'absent', platform: 'android' })
     console.log('Immediate absent test:', r1 && (r1 as any).success ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r1 as any).poll_count, duration_ms: (r1 as any).duration_ms, stable_duration_ms: (r1 as any).stable_duration_ms, matchSource: (r1 as any).matchSource }, null, 2))
 
     // 2) Boundary stability: condition becomes true and stays exactly long enough
     // Use pollInterval 100ms and stability 300ms -> need ~3 consecutive trues
     let seq2 = [false, true, true, true]
     (ToolsInteract as any).findElementHandler = async () => ({ found: seq2.shift() ?? true })
-    const r2 = await (ToolsInteract as any).observeUntilHandler({ type: 'ui', query: 'Boundary', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 300, match: 'present', platform: 'android' })
+    const r2 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Boundary', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 300, match: 'present', platform: 'android' })
     console.log('Boundary stability test:', r2 && (r2 as any).success ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r2 as any).poll_count, duration_ms: (r2 as any).duration_ms, stable_duration_ms: (r2 as any).stable_duration_ms, matchSource: (r2 as any).matchSource }, null, 2))
 
     // 3) Long flicker that never stabilizes should timeout/fail
     // Sequence toggles true/false repeatedly
     let seq3 = [false, true, false, true, false, true, false]
     (ToolsInteract as any).findElementHandler = async () => ({ found: seq3.shift() ?? false })
-    const r3 = await (ToolsInteract as any).observeUntilHandler({ type: 'ui', query: 'Flicker', timeoutMs: 1200, pollIntervalMs: 150, stability_ms: 400, match: 'present', platform: 'android' })
+    const r3 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Flicker', timeoutMs: 1200, pollIntervalMs: 150, stability_ms: 400, match: 'present', platform: 'android' })
     console.log('Long flicker timeout test:', !(r3 && (r3 as any).success) ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r3 as any).poll_count, duration_ms: (r3 as any).duration_ms, stable_duration_ms: (r3 as any).stable_duration_ms, matchSource: (r3 as any).matchSource }, null, 2))
 
     // 4) Very short stability requirement should pass quickly
     (ToolsInteract as any).findElementHandler = async () => ({ found: true })
-    const r4 = await (ToolsInteract as any).observeUntilHandler({ type: 'ui', query: 'ShortStable', timeoutMs: 2000, pollIntervalMs: 200, stability_ms: 50, match: 'present', platform: 'android' })
+    const r4 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'ShortStable', timeoutMs: 2000, pollIntervalMs: 200, stability_ms: 50, match: 'present', platform: 'android' })
     console.log('Short stability test:', r4 && (r4 as any).success ? 'PASS' : 'FAIL', JSON.stringify({ poll_count: (r4 as any).poll_count, duration_ms: (r4 as any).duration_ms, stable_duration_ms: (r4 as any).stable_duration_ms, matchSource: (r4 as any).matchSource }, null, 2))
 
   } finally {

package/test/observe/unit/{observe_until_stability.test.ts → wait_for_ui_stability.test.ts}

@@ -2,7 +2,7 @@ import { ToolsInteract } from '../../../../src/interact/index.js'
 import * as Observe from '../../../../src/observe/index.js'
 
 async function run() {
-  console.log('Unit: observe_until stability behavior')
+  console.log('Unit: wait_for_ui stability behavior')
 
   const origFind = (ToolsInteract as any).findElementHandler
   const origFp = (Observe as any).ToolsObserve.getScreenFingerprintHandler
@@ -12,13 +12,13 @@ async function run() {
     const seq = [false, true, false, true, true, true]
     (ToolsInteract as any).findElementHandler = async () => ({ found: seq.shift() ?? true })
 
-    const res = await (ToolsInteract as any).observeUntilHandler({ type: 'ui', query: 'X', timeoutMs: 5000, pollIntervalMs: 100, stability_ms: 500, platform: 'android' })
+    const res = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'X', timeoutMs: 5000, pollIntervalMs: 100, stability_ms: 500, platform: 'android' })
     const ok = res && (res as any).success
     console.log('Flicker stability test:', ok ? 'PASS' : 'FAIL', JSON.stringify((res as any).telemetry || {}, null, 2))
 
     // Simulate immediate stable presence
     (ToolsInteract as any).findElementHandler = async () => ({ found: true })
-    const res2 = await (ToolsInteract as any).observeUntilHandler({ type: 'ui', query: 'Y', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 300, platform: 'android' })
+    const res2 = await (ToolsInteract as any).waitForUIHandler({ type: 'ui', query: 'Y', timeoutMs: 2000, pollIntervalMs: 100, stability_ms: 300, platform: 'android' })
     console.log('Immediate stable test:', res2 && (res2 as any).success ? 'PASS' : 'FAIL', JSON.stringify((res2 as any).telemetry || {}, null, 2))
 
   } finally {

package/test/unit/index.ts

@@ -1,18 +1,30 @@
 // Aggregator entrypoint for unit tests (updated to new test layout)
-import '../observe/unit/logparse.test.ts'
-import '../observe/unit/logstream.test.ts'
-import '../observe/unit/wait_for_element_mock.ts'
-import '../observe/unit/get_screen_fingerprint.test.ts'
+(async function() {
+  // Core unit tests that do not require real devices
+  await import('../observe/unit/logparse.test.ts')
+  await import('../observe/unit/logstream.test.ts')
+  await import('../observe/unit/get_screen_fingerprint.test.ts')
 
-import '../manage/unit/install.test.ts'
-import '../manage/unit/build.test.ts'
-import '../manage/unit/build_and_install.test.ts'
-import '../manage/unit/diagnostics.test.ts'
-import '../manage/unit/detection.test.ts'
-import '../manage/unit/mcp_disable_autodetect.test.ts'
-import '../interact/unit/wait_for_screen_change.test.ts'
-import '../observe/unit/capture_debug_snapshot.test.ts'
-import '../observe/unit/find_element.test.ts'
-import '../interact/unit/observe_until.test.ts'
+  await import('../manage/unit/install.test.ts')
+  await import('../manage/unit/build.test.ts')
+  await import('../manage/unit/build_and_install.test.ts')
+  await import('../manage/unit/diagnostics.test.ts')
+  await import('../manage/unit/detection.test.ts')
+  await import('../manage/unit/mcp_disable_autodetect.test.ts')
+  await import('../interact/unit/wait_for_screen_change.test.ts')
 
-console.log('Unit tests loaded.')
+  // Conditionally include device-dependent unit tests. Set SKIP_DEVICE_TESTS=1 to exclude.
+  if (process.env.SKIP_DEVICE_TESTS !== '1') {
+    try {
+      await import('../observe/unit/capture_debug_snapshot.test.ts')
+      await import('../observe/unit/find_element.test.ts')
+      await import('../interact/unit/wait_for_ui.test.ts')
+    } catch (e) {
+      console.warn('Skipping some device-dependent tests due to import error:', e instanceof Error ? e.message : String(e))
+    }
+  } else {
+    console.log('SKIP_DEVICE_TESTS=1 detected - skipping device-dependent unit tests')
+  }
+
+  console.log('Unit tests loaded.')
+})().catch(e => { console.error(e); process.exit(1) })