mobile-debug-mcp 0.26.3 → 0.26.5

package/test/unit/observe/find_element.test.ts

@@ -78,6 +78,52 @@ async function run() {
     assert.ok((res4.resolution?.alternates || []).length >= 1, 'Parent promotion should preserve alternates')
     process.stdout.write('Test 4: ' + (pass4 ? 'PASS' : 'FAIL') + '\n');
 
+    // Test 4b: semantic-only stepper should be discoverable by supported action
+    ;(ToolsObserve as any).getUITreeHandler = async () => ({
+      device: { platform: 'android', id: 'mock' },
+      screen: '',
+      resolution: { width: 1080, height: 1920 },
+      elements: [
+        {
+          text: null,
+          contentDescription: 'Quantity stepper',
+          type: 'android.widget.NumberPicker',
+          clickable: false,
+          enabled: true,
+          visible: true,
+          bounds: [10,10,200,80],
+          resourceId: 'picker_quantity',
+          semantic: {
+            is_clickable: false,
+            is_container: true,
+            semantic_role: 'stepper',
+            supported_actions: ['increment', 'decrement'],
+            adjustable: true,
+            state_shape: 'discrete'
+          }
+        }
+      ]
+    })
+
+    const res4b: any = await ToolsInteract.findElementHandler({ query: 'increment', exact: false, platform: 'android', timeoutMs: 300 })
+    process.stdout.write('res4b ' + JSON.stringify(res4b, null, 2) + '\n');
+    const pass4b = res4b.found === true && res4b.element && res4b.element.resourceId === 'picker_quantity' && res4b.element.semantic?.semantic_role === 'stepper'
+    assert.ok(pass4b, 'Semantic-only steppers should be discoverable by supported actions')
+    assert.strictEqual(res4b.resolution?.reason, 'semantic_action_match')
+    process.stdout.write('Test 4b: ' + (pass4b ? 'PASS' : 'FAIL') + '\n');
+
+    const res4bb: any = await ToolsInteract.findElementHandler({ query: 'increment', exact: true, platform: 'android', timeoutMs: 300 })
+    process.stdout.write('res4bb ' + JSON.stringify(res4bb, null, 2) + '\n');
+    const pass4bb = res4bb.found === true && res4bb.element && res4bb.element.resourceId === 'picker_quantity' && res4bb.resolution?.reason === 'semantic_action_match'
+    assert.ok(pass4bb, 'Exact searches should still match exact semantic actions')
+    process.stdout.write('Test 4bb: ' + (pass4bb ? 'PASS' : 'FAIL') + '\n');
+
+    const res4c: any = await ToolsInteract.findElementHandler({ query: 'control', exact: true, platform: 'android', timeoutMs: 300 })
+    process.stdout.write('res4c ' + JSON.stringify(res4c, null, 2) + '\n');
+    const pass4c = res4c.found === false
+    assert.ok(pass4c, 'Exact searches should not fall back to broad semantic keywords')
+    process.stdout.write('Test 4c: ' + (pass4c ? 'PASS' : 'FAIL') + '\n');
+
     // Test 5: duration label should resolve to the nearby slider control
     ;(ToolsObserve as any).getUITreeHandler = async () => ({
       device: { platform: 'android', id: 'mock' },

package/test/unit/observe/state_extraction.test.ts

@@ -29,7 +29,43 @@ async function run() {
     value: 'com.example:id/duration',
     confidence: { score: 1, reason: 'resource_id' }
   })
-  assert.deepStrictEqual(androidElements[0].semantic, { is_clickable: true, is_container: false })
+  assert.deepStrictEqual(androidElements[0].semantic, {
+    is_clickable: true,
+    is_container: false,
+    semantic_role: 'slider',
+    supported_actions: ['adjust'],
+    adjustable: true,
+    state_shape: 'continuous'
+  })
+
+  const androidProgressElements: any[] = []
+  traverseNode({
+    '@_class': 'android.widget.ProgressBar',
+    '@_text': 'Loading progress',
+    '@_content-desc': 'Loading progress',
+    '@_enabled': 'true',
+    '@_progress': '40',
+    '@_max': '100',
+    '@_bounds': '[0,0][200,40]'
+  }, androidProgressElements)
+
+  assert.notStrictEqual(androidProgressElements[0]?.role, 'slider')
+  assert.notStrictEqual(androidProgressElements[0]?.state?.value, 40)
+  assert.notStrictEqual(androidProgressElements[0]?.semantic?.adjustable, true)
+
+  const androidStepperElements: any[] = []
+  traverseNode({
+    '@_class': 'android.widget.NumberPicker',
+    '@_text': 'Quantity',
+    '@_content-desc': 'Quantity stepper',
+    '@_clickable': 'false',
+    '@_enabled': 'true',
+    '@_bounds': '[0,0][200,80]'
+  }, androidStepperElements)
+  assert.strictEqual(androidStepperElements[0].role, 'stepper')
+  assert.deepStrictEqual(androidStepperElements[0].semantic?.semantic_role, 'stepper')
+  assert.deepStrictEqual(androidStepperElements[0].semantic?.supported_actions, ['increment', 'decrement'])
+  assert.strictEqual(androidStepperElements[0].semantic?.adjustable, true)
 
   const androidFallbackElements: any[] = []
   traverseNode({
@@ -68,7 +104,58 @@ async function run() {
     value: 'playback_speed_slider',
     confidence: { score: 1, reason: 'accessibility_identifier' }
   })
-  assert.deepStrictEqual(iosElements[0].semantic, { is_clickable: true, is_container: false })
+  assert.deepStrictEqual(iosElements[0].semantic, {
+    is_clickable: true,
+    is_container: false,
+    semantic_role: 'slider',
+    supported_actions: ['adjust'],
+    adjustable: true,
+    state_shape: 'continuous'
+  })
+
+  const iosProgressElements: any[] = []
+  traverseIDBNode({
+    AXElementType: 'ProgressIndicator',
+    AXLabel: 'Loading progress',
+    AXValue: '0.4',
+    AXTraits: ['UIAccessibilityTraitUpdatesFrequently']
+  }, iosProgressElements)
+
+  assert.notStrictEqual(iosProgressElements[0]?.role, 'slider')
+
+  const iosStepperElements: any[] = []
+  traverseIDBNode({
+    AXElementType: 'Stepper',
+    AXLabel: 'Quantity',
+    AXValue: '1',
+    AXTraits: ['UIAccessibilityTraitAdjustable']
+  }, iosStepperElements)
+  assert.strictEqual(iosStepperElements[0].role, 'stepper')
+  assert.strictEqual(iosStepperElements[0].semantic?.semantic_role, 'stepper')
+  assert.deepStrictEqual(iosStepperElements[0].semantic?.supported_actions, ['increment', 'decrement'])
+  assert.strictEqual(iosStepperElements[0].semantic?.state_shape, 'discrete')
+
+  const iosSegmentedElements: any[] = []
+  traverseIDBNode({
+    AXElementType: 'Segmented Control',
+    AXLabel: 'Playback mode',
+    AXTraits: ['UIAccessibilityTraitButton']
+  }, iosSegmentedElements)
+  assert.strictEqual(iosSegmentedElements[0].role, 'segmented_control')
+  assert.strictEqual(iosSegmentedElements[0].semantic?.semantic_role, 'segmented_control')
+  assert.deepStrictEqual(iosSegmentedElements[0].semantic?.supported_actions, ['tap'])
+
+  const iosCustomAdjustableElements: any[] = []
+  traverseIDBNode({
+    AXElementType: 'CustomControl',
+    AXLabel: 'Intensity',
+    AXValue: '0.25',
+    AXTraits: ['UIAccessibilityTraitAdjustable']
+  }, iosCustomAdjustableElements)
+  assert.strictEqual(iosCustomAdjustableElements[0].semantic?.semantic_role, 'custom_adjustable')
+  assert.strictEqual(iosCustomAdjustableElements[0].semantic?.adjustable, true)
+  assert.deepStrictEqual(iosCustomAdjustableElements[0].semantic?.supported_actions, ['adjust'])
+  assert.strictEqual(iosCustomAdjustableElements[0].semantic?.state_shape, 'continuous')
 
   const iosFallbackElements: any[] = []
   traverseIDBNode({

package/test/unit/server/contract.test.ts

@@ -16,6 +16,7 @@ async function run() {
   assert(names.includes('capture_screenshot'))
   assert(names.includes('get_ui_tree'))
   assert(names.includes('tap_element'))
+  assert(names.includes('adjust_control'))
 
   const waitForUI = toolDefinitions.find((tool) => tool.name === 'wait_for_ui')
   assert(waitForUI, 'wait_for_ui should be registered')
@@ -66,6 +67,13 @@ async function run() {
   assert.match((expectElementVisible as any).description, /selector is the primary input/i)
   assert.match((expectElementVisible as any).description, /Returns structured binary success\/failure only/i)
 
+  const adjustControl = toolDefinitions.find((tool) => tool.name === 'adjust_control')
+  assert(adjustControl, 'adjust_control should be registered')
+  assert.deepStrictEqual((adjustControl as any).inputSchema.required, ['targetValue'])
+  assert.strictEqual((adjustControl as any).inputSchema.properties.targetValue.type, 'number')
+  assert.match((adjustControl as any).description, /numeric control value/i)
+  assert.match((adjustControl as any).description, /expect_state/i)
+
   const classifyActionOutcome = toolDefinitions.find((tool) => tool.name === 'classify_action_outcome')
   assert(classifyActionOutcome, 'classify_action_outcome should be registered')
   assert.match((classifyActionOutcome as any).description, /action_type/i)

package/test/unit/server/response_shapes.test.ts

@@ -14,6 +14,7 @@ async function run() {
   const originalExpectScreenHandler = (ToolsInteract as any).expectScreenHandler
   const originalExpectElementVisibleHandler = (ToolsInteract as any).expectElementVisibleHandler
   const originalExpectStateHandler = (ToolsInteract as any).expectStateHandler
+  const originalAdjustControlHandler = (ToolsInteract as any).adjustControlHandler
   const originalStartApp = AndroidManage.prototype.startApp
   const originalCaptureScreenshotHandler = (ToolsObserve as any).captureScreenshotHandler
   const originalGetUITreeHandler = (ToolsObserve as any).getUITreeHandler
@@ -191,6 +192,43 @@ async function run() {
     assert.strictEqual(expectStatePayload.expected_state.property, 'checked')
     assert.strictEqual(expectStatePayload.observed_state.value, true)
 
+    ;(ToolsInteract as any).adjustControlHandler = async () => ({
+      action_id: 'adjust_control_1',
+      timestamp: '2026-04-29T08:00:00.000Z',
+      action_type: 'adjust_control',
+      lifecycle_state: 'pending_verification',
+      source_module: 'interact',
+      target: {
+        selector: { elementId: 'el_duration' },
+        resolved: {
+          elementId: 'el_duration',
+          text: 'Duration',
+          resource_id: null,
+          accessibility_id: null,
+          class: 'android.view.View',
+          bounds: [0, 0, 100, 20],
+          index: 0
+        }
+      },
+      success: true,
+      ui_fingerprint_before: 'fp_before',
+      ui_fingerprint_after: 'fp_after',
+      target_state: { property: 'value', target_value: 30, tolerance: 0.5 },
+      actual_state: { property: 'value', value: 30, raw_value: 30 },
+      within_tolerance: true,
+      converged: true,
+      attempts: 1,
+      adjustment_mode: 'semantic'
+    })
+
+    const adjustControlResponse = await handleToolCall('adjust_control', { element_id: 'el_duration', targetValue: 30, tolerance: 0.5, property: 'value' })
+    const adjustControlPayload = JSON.parse((adjustControlResponse as any).content[0].text)
+    assert.strictEqual(adjustControlPayload.success, true)
+    assert.strictEqual(adjustControlPayload.action_type, 'adjust_control')
+    assert.strictEqual(adjustControlPayload.target_state.target_value, 30)
+    assert.strictEqual(adjustControlPayload.within_tolerance, true)
+    assert.strictEqual(adjustControlPayload.converged, true)
+
     ;(ToolsInteract as any).tapHandler = async () => {
       throw new Error('boom')
     }
@@ -319,6 +357,7 @@ async function run() {
     ;(ToolsObserve as any).getUITreeHandler = originalGetUITreeHandler
     ;(ToolsObserve as any).getScreenFingerprintHandler = originalGetScreenFingerprintHandler
     ;(ToolsObserve as any).captureDebugSnapshotHandler = originalCaptureDebugSnapshotHandler
+    ;(ToolsInteract as any).adjustControlHandler = originalAdjustControlHandler
   }
 }