mobile-debug-mcp 0.33.0 → 0.35.0

package/src/interact/assertions/visibility-assertion.ts

@@ -0,0 +1,41 @@
+import type { UiSelector } from '../../contracts/selector.js'
+import type { ActionTargetResolved, ExpectElementVisibleResponse } from '../../types.js'
+import type { DeviceTarget } from '../observation.js'
+import type { UIWaitInput, UIWaitResult } from '../waits/ui-wait-state.js'
+import { buildObservationTrace } from '../interaction-trace.js'
+export interface VisibilityInput extends DeviceTarget { selector: UiSelector; element_id?: string; timeout_ms?: number; poll_interval_ms?: number }
+export type WaitUI = (input: UIWaitInput) => Promise<UIWaitResult | undefined>
+function visibleElement(element: ActionTargetResolved): ActionTargetResolved {
+  return { elementId: element.elementId ?? null, text: element.text ?? null, resource_id: element.resource_id ?? null,
+    accessibility_id: element.accessibility_id ?? null, class: element.class ?? null, bounds: element.bounds ?? null,
+    index: typeof element.index === 'number' ? element.index : null, state: element.state ?? null,
+    stable_id: element.stable_id ?? null, role: element.role ?? null, test_tag: element.test_tag ?? null,
+    selector: element.selector ?? null, semantic: element.semantic ?? null }
+}
+function visibleSuccess(input: VisibilityInput, result: UIWaitResult, element: ActionTargetResolved): ExpectElementVisibleResponse {
+  const id = element.elementId ?? input.element_id ?? null
+  return { success: true, selector: input.selector, element_id: id, expected_condition: 'visible', element: visibleElement(element),
+    observed: { status: result.status, matched_count: typeof result.matched === 'number' ? result.matched : result.observed?.matched_count ?? null,
+      condition_satisfied: true, selected_index: typeof element.index === 'number' ? element.index : null, last_matched_element: visibleElement(element) },
+    reason: 'selector is visible', trace: buildObservationTrace({ actionType: 'expect_element_visible', stage: 'verify', success: true, attempts: 1,
+      metadata: { selector: input.selector, element_id: id, status: result.status } }) }
+}
+function visibleFailure(input: VisibilityInput, result: UIWaitResult | undefined): ExpectElementVisibleResponse {
+  const code = result?.error?.code === 'INTERNAL_ERROR' ? 'UNKNOWN' : 'TIMEOUT'
+  const reason = result?.error?.message ?? 'selector is not visible'
+  return { success: false, selector: input.selector, element_id: input.element_id ?? null, expected_condition: 'visible',
+    observed: failureObserved(result), reason, failure_code: code, retryable: code === 'TIMEOUT',
+    trace: buildObservationTrace({ actionType: 'expect_element_visible', stage: 'verify', success: false, attempts: 1,
+      metadata: { selector: input.selector, element_id: input.element_id ?? null, status: result?.status ?? null, reason } }) }
+}
+export async function expectVisible({ selector, element_id, timeout_ms = 5000, poll_interval_ms = 300, platform, deviceId }: VisibilityInput, wait: WaitUI) {
+  const result = await wait({ selector, condition: 'visible', timeout_ms, poll_interval_ms, platform, deviceId })
+  const input = { selector, element_id, platform, deviceId }
+  return result?.status === 'success' && result.element ? visibleSuccess(input, result, result.element) : visibleFailure(input, result)
+}
+
+function failureObserved(result: UIWaitResult | undefined) {
+  return { status: result?.status, matched_count: result?.observed?.matched_count,
+    condition_satisfied: result?.observed?.condition_satisfied ?? false,
+    selected_index: result?.observed?.selected_index ?? null, last_matched_element: result?.observed?.last_matched_element ?? null }
+}

package/src/interact/conditional-action.ts

@@ -1,10 +1,10 @@
 import { AsyncLocalStorage } from 'node:async_hooks'
 import type { ActionConditionResult } from '../types.js'
-import type { ExpectedState } from '../server/condition-schema.js'
+import type { ExpectedState } from '../contracts/condition.js'
 import { ToolsObserve } from '../observe/index.js'
 import { getSnapshotSessionId, hasSnapshotBaseline } from '../observe/snapshot-metadata.js'
 import { runWithSeparateBudget } from '../utils/operation-budget.js'
-import { ToolsNetwork } from '../network/index.js'
+import { ToolsNetwork } from '../observe/network/index.js'
 
 export interface ConditionalAction {
   platform: 'android' | 'ios'
@@ -16,11 +16,13 @@ export interface ConditionalAction {
 const context = new AsyncLocalStorage<ConditionalAction>()
 
 export function createConditionalAction(platform: 'android' | 'ios', deviceId: string, expected: ExpectedState): ConditionalAction {
-  return { platform, deviceId, expected, result: {
-    status: 'not_checked',
-    expected: { snapshot_session_id: expected.snapshotSessionId, snapshot_revision: expected.snapshotRevision },
-    observed: null, elapsed_ms: 0, reason: 'ACTION_NOT_REACHED'
-  } }
+  return {
+    platform, deviceId, expected, result: {
+      status: 'not_checked',
+      expected: { snapshot_session_id: expected.snapshotSessionId, snapshot_revision: expected.snapshotRevision },
+      observed: null, elapsed_ms: 0, reason: 'ACTION_NOT_REACHED'
+    }
+  }
 }
 
 export function withConditionalAction<T>(condition: ConditionalAction, operation: () => Promise<T>) {
@@ -54,12 +56,9 @@ export async function beforeInputDispatch(platform: 'android' | 'ios', deviceId:
     else if (!hasSnapshotBaseline(`${platform}:${deviceId}`, condition.expected.snapshotRevision)) result.reason = 'BASELINE_UNAVAILABLE'
     else {
       const tree = await runWithSeparateBudget(condition.expected.timeoutMs ?? 15000, () =>
-        ToolsObserve.getUITreeHandler({ platform, deviceId })) as any
+        ToolsObserve.getUITreeHandler({ platform, deviceId }))
       if (tree?.error) result.reason = 'OBSERVATION_FAILED'
-      else if (!tree || !Array.isArray(tree.elements) || !Number.isSafeInteger(tree.snapshot_revision) || tree.snapshot_revision < 1 ||
-          tree.snapshot_session_id !== getSnapshotSessionId() || !Number.isFinite(tree.captured_at_ms) || tree.captured_at_ms <= 0 ||
-          !tree.resolution || !Number.isFinite(tree.resolution.width) || !Number.isFinite(tree.resolution.height) ||
-          !(tree.resolution.width > 0) || !(tree.resolution.height > 0)) result.reason = 'OBSERVATION_INVALID'
+      else if (invalidConditionSnapshot(tree)) result.reason = 'OBSERVATION_INVALID'
       else if (tree.device?.platform !== platform || tree.device?.id !== deviceId) result.reason = 'DEVICE_MISMATCH'
       else {
         result.observed = tree
@@ -73,3 +72,10 @@ export async function beforeInputDispatch(platform: 'android' | 'ios', deviceId:
   if (result.status !== 'matched') throw new Error(conditionFailureCode(condition))
   ToolsNetwork.notifyActionStart()
 }
+
+function invalidConditionSnapshot(tree: import('../types.js').GetUITreeResponse | null | undefined) {
+  return !tree || !Array.isArray(tree.elements) || !Number.isSafeInteger(tree.snapshot_revision) || tree.snapshot_revision < 1 ||
+    tree.snapshot_session_id !== getSnapshotSessionId() || !Number.isFinite(tree.captured_at_ms) || tree.captured_at_ms <= 0 ||
+    !tree.resolution || !Number.isFinite(tree.resolution.width) || !Number.isFinite(tree.resolution.height) ||
+    !(tree.resolution.width > 0) || !(tree.resolution.height > 0)
+}